Contract 0x86fe3c20379ac71ebbf8c0499b41fd2b457e4e9e

 

TxHash Block Age From To Value [TxFee]
0x20a4fb95acf72f450b53f8a31d4573536a3e87ee9ba915d1aeaccd7ab29a576c707094136 days 9 hrs ago0x406aeb34cc480975aa1ae911cb7d3487996e618a IN  Trade.io_TokenSale0 Ether0.002157092
0x2cbb445665e3b19ca5dd3e0e5e28f74641510a8b50cb8482bb8946950bbbcc916600927115 days 5 hrs ago0x7e6ae81835ad643a2326e06626a301fb010067d7 IN  Trade.io_TokenSale0 Ether0.00225672
0x04c50bb7210a895d4fe64a994a123a5e9f88ded493fe3225593a8b9e4511c3626257857171 days 14 hrs ago0xbf03af50861ac228d99bc5c1eef06f1665fe8b43 IN  Trade.io_TokenSale0 Ether0.002157092
0x797daf9b084c8b3cbae080e1cc51a40e038db8d2260b322c799e9c5273cd30366173918185 days 18 hrs ago0xbbfffd552404bce5164b448b22400a49c78f831b IN  Trade.io_TokenSale0 Ether0.00315672
0xaac585550785c533755ffb5f471e01e220b90c78256fe8c5b40f685abd72707c6046438207 days 6 hrs ago0x5ff749d4974894f9be2d5cad8909c3ff50a8b77e IN  Trade.io_TokenSale0 Ether0.002157092
0x81ace076d5806812285662c250c70aa65d1f46f45a9dd84e86fcd6c72e23221d6046359207 days 7 hrs ago0x5ff749d4974894f9be2d5cad8909c3ff50a8b77e IN  Trade.io_TokenSale0 Ether0.002387266
0x1f659bacd05e70be5969f613a7552ebe687cbfc89cb4e609016940d3771615ff6046325207 days 7 hrs ago0x5ff749d4974894f9be2d5cad8909c3ff50a8b77e IN  Trade.io_TokenSale0 Ether0.00116452
0x419e8b7c8694c7765b2353de8161f3464b3e0055dcd9cac9e381f851078415d45899950232 days 5 hrs ago0x777487cff709f3ff3b1a2c52675b0ccd5b40721c IN  Trade.io_TokenSale0 Ether0.002157092
0xd3d2d82a34b88d5cb9e7639ac340b69288ae56e019803f08a044ec384f9edec65897709232 days 14 hrs ago0x24956592e6a4f5d509820a81ee04365e877c7f52 IN  Trade.io_TokenSale0 Ether0.00315672
0xb538b0c780aab8ab58eb2585e8b46f355646ff0d1b99474c181f6e625fc200c45894961233 days 1 hr ago0x777487cff709f3ff3b1a2c52675b0ccd5b40721c IN  Trade.io_TokenSale0 Ether0.00044
0x20fa5f1ee11b85cc8dacbe5d4162d9f553a29e84e17ad95c13d32aeecb0c822f5870524237 days 5 hrs ago0xe3bbb8a79e63ee5b3ddb9ce020df6368bd7b20a3 IN  Trade.io_TokenSale0 Ether0.00315672
0x6e1b0524235a3199afeeaad3185e634995cdaf59085f527ce3d203e7c6f77f725837269242 days 23 hrs ago0xb037b091aa2008c70022e2ef054e9ae9b210b6fe IN  Trade.io_TokenSale1 Ether0.002239174
0xdd1ceae49338ec9435393afc4392af8a0aff05ccd801dc8fa9655c7b00ea14c55832360243 days 19 hrs ago0xf447c1b188bceaac085aad4edd525e027e9d8bf0 IN  Trade.io_TokenSale0 Ether0.0052612
0xfeb11a7cb38a031b06f446c65c1d9ce4dc40aad1ca5dd18c60a8f5d09016352f5831385243 days 23 hrs ago0xcb3d602c347b175b22d6dccd7e40c863fefd77b0 IN  Trade.io_TokenSale0 Ether0.0022761
0x023880c1f53d5324187c9b1a46a9476decf9f94f3a7195f9f5a3834885aebe315831347243 days 23 hrs ago0xcb3d602c347b175b22d6dccd7e40c863fefd77b0 IN  Trade.io_TokenSale0.5 Ether0.002185218
0xe076176bf902a9d70a55b61bdc0092c7a3b39006a96eebbffaa9c9287b1a22c85829210244 days 8 hrs ago0x34712b84e1f21e61ad6b0192f5fc78477a1b39c1 IN  Trade.io_TokenSale0 Ether0.002683212
0xb77bee298c044c88941623ff9effb28d5d1fa347e87137b8207708ff15642bb35819708245 days 23 hrs ago0xca7e5dfaba4071b7143d3562513f7ec38cfdd8ce IN  Trade.io_TokenSale0 Ether0.00315672
0xaec9198d3215777517b80e9d7409253619d3be56aab227462edfb4389fecac995809405247 days 17 hrs ago0xbae9990dc5de7a6e5de80a0415e27e95a570f576 IN  Trade.io_TokenSale0 Ether0.001124
0xd17b15eb2884bea79d360b09566f75418b139b5f612e03ac4f9b14462d2320495787823251 days 10 hrs ago0x0d757552d3c41ecd15d0332fe4f9b5f6ce872728 IN  Trade.io_TokenSale0 Ether0.00315672
0xa49217812758474d4725ddf52386548d06bb8a1cfae0545d6b4727a89f941f165749562258 days 3 hrs ago0x16146df8b5f07bf1dc3df2c5860218a4346f9077 IN  Trade.io_TokenSale0 Ether0.0011521
0xfc7d3533278b6e4322326f398190d0fbdcf76872063f82abb0223d090991adda5707094265 days 16 hrs ago0x5267039351b26f22493c478ca64fb739ccf2827e IN  Trade.io_TokenSale0 Ether0.002157092
0x3e1a01c78e24f345e80aa145466e06c69329f36c20d61072716e09efc3567ffa5706912265 days 17 hrs ago0xfc062856bc0b9257e2a1d21f12a6c4820d3b14e5 IN  Trade.io_TokenSale0 Ether0.000843
0x933062822521556e7fd70c390469294173e61d0c292bf05b0523375998bba9015706661265 days 18 hrs ago0xfc4dfe7aff9bc19836b7e752c3e38566a3463b83 IN  Trade.io_TokenSale0 Ether0.001104852
0xa32b554ae9bfe869bd794c08f9656a95fe3e0152ebd8de6d4dcacd8be012cffe5704364266 days 4 hrs ago0xb7d07e12dfb6165f6a6b560eecf4784cad927675 IN  Trade.io_TokenSale0 Ether0.00052612
0xf7715cbc8b49fd1f45d2bcd545c2765c74ccf3f730308c67ad2a9238021cabf15666860272 days 19 hrs ago0x667e407d6e3ff6b505cf3d9355f32cbb9d8ce2f3 IN  Trade.io_TokenSale0 Ether0.0017984
[ Download CSV Export 

Latest 1 Internal Transaction Internal Transactions as a result of Contract Execution

Parent TxHash Block Age From To Value
0x9acff710f1cd3c24f1082d2a30a34ddb909c1b6ae58d260a562de85e515ebc1d4859380411 days 6 hrs ago0x86fe3c20379ac71ebbf8c0499b41fd2b457e4e9e0x58f75ddacffb183a30f69fe58a67a0d0985fce0f14,943.382230548655115113 Ether
[ Download CSV Export 
Warning: The compiled contract might be susceptible to ExpExponentCleanup (medium/high-severity), EventStructWrongData (very low-severity), NestedArrayFunctionCallDecoder (medium-severity) Solidity Compiler Bugs.

Contract Source Code Verified (Exact Match)
Contract Name: TIOCrowdsale
Compiler Version: v0.4.18+commit.9cf6e910
Optimization Enabled: No
Runs (Optimizer):  0


Contract Source Code
pragma solidity ^0.4.18;

/**
 * TradeToken Crowdsale Contract
 *
 * This is the crowdsale contract for the TradeToken. It utilizes Majoolr's
 * CrowdsaleLib library to reduce custom source code surface area and increase
 * overall security.Majoolr provides smart contract services and security reviews
 * for contract deployments in addition to working on open source projects in the
 * Ethereum community.
 * For further information: trade.io, majoolr.io
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */

contract TIOCrowdsale {
  using DirectCrowdsaleLib for DirectCrowdsaleLib.DirectCrowdsaleStorage;

  DirectCrowdsaleLib.DirectCrowdsaleStorage sale;
  bool public greenshoeActive;
  function TIOCrowdsale(
                address owner,
                uint256[] saleData,           // [1512633600, 50, 0, 1513238400, 56, 0, 1513843200, 64, 0, 1514448000, 75, 0]
                uint256 fallbackExchangeRate, // 45000
                uint256 capAmountInCents,     // 24750000000
                uint256 endTime,              // 1515052740
                uint8 percentBurn,            // 100
                CrowdsaleToken token)         // 0x80bc5512561c7f85a3a9508c7df7901b370fa1df
  {
  	sale.init(owner, saleData, fallbackExchangeRate, capAmountInCents, endTime, percentBurn, token);
  }

  // fallback function can be used to buy tokens
  function () payable {
    sendPurchase();
  }

  function sendPurchase() payable returns (bool) {
    uint256 _tokensSold = getTokensSold();
    if(_tokensSold > 270000000000000000000000000 && (!greenshoeActive)){
      bool success = activateGreenshoe();
      assert(success);
    }
  	return sale.receivePurchase(msg.value);
  }

  function activateGreenshoe() private returns (bool) {
    uint256 _currentPrice = sale.base.saleData[sale.base.milestoneTimes[sale.base.currentMilestone]][0];
    while(sale.base.milestoneTimes.length > sale.base.currentMilestone + 1)
    {
      sale.base.currentMilestone += 1;
      sale.base.saleData[sale.base.milestoneTimes[sale.base.currentMilestone]][0] = _currentPrice;
    }
    greenshoeActive = true;
    return true;
  }

  function withdrawTokens() returns (bool) {
  	return sale.withdrawTokens();
  }

  function withdrawLeftoverWei() returns (bool) {
    return sale.withdrawLeftoverWei();
  }

  function withdrawOwnerEth() returns (bool) {
    return sale.withdrawOwnerEth();
  }

  function crowdsaleActive() constant returns (bool) {
    return sale.crowdsaleActive();
  }

  function crowdsaleEnded() constant returns (bool) {
    return sale.crowdsaleEnded();
  }

  function setTokenExchangeRate(uint256 _exchangeRate) returns (bool) {
    return sale.setTokenExchangeRate(_exchangeRate);
  }

  function setTokens() returns (bool) {
    return sale.setTokens();
  }

  function getOwner() constant returns (address) {
    return sale.base.owner;
  }

  function getTokensPerEth() constant returns (uint256) {
    return sale.base.tokensPerEth;
  }

  function getExchangeRate() constant returns (uint256) {
    return sale.base.exchangeRate;
  }

  function getCapAmount() constant returns (uint256) {
    if(!greenshoeActive) {
      return sale.base.capAmount - 160000000000000000000000;
    } else {
      return sale.base.capAmount;
    }
  }

  function getStartTime() constant returns (uint256) {
    return sale.base.startTime;
  }

  function getEndTime() constant returns (uint256) {
    return sale.base.endTime;
  }

  function getEthRaised() constant returns (uint256) {
    return sale.base.ownerBalance;
  }

  function getContribution(address _buyer) constant returns (uint256) {
  	return sale.base.hasContributed[_buyer];
  }

  function getTokenPurchase(address _buyer) constant returns (uint256) {
  	return sale.base.withdrawTokensMap[_buyer];
  }

  function getLeftoverWei(address _buyer) constant returns (uint256) {
    return sale.base.leftoverWei[_buyer];
  }

  function getSaleData(uint256 timestamp) constant returns (uint256[3]) {
    return sale.getSaleData(timestamp);
  }

  function getTokensSold() constant returns (uint256) {
    return sale.base.startingTokenBalance - sale.base.withdrawTokensMap[sale.base.owner];
  }

  function getPercentBurn() constant returns (uint256) {
    return sale.base.percentBurn;
  }
}

library DirectCrowdsaleLib {
  using BasicMathLib for uint256;
  using CrowdsaleLib for CrowdsaleLib.CrowdsaleStorage;

  struct DirectCrowdsaleStorage {

  	CrowdsaleLib.CrowdsaleStorage base; // base storage from CrowdsaleLib

  }

  event LogTokensBought(address indexed buyer, uint256 amount);
  event LogAddressCapExceeded(address indexed buyer, uint256 amount, string Msg);
  event LogErrorMsg(uint256 amount, string Msg);
  event LogTokenPriceChange(uint256 amount, string Msg);


  /// @dev Called by a crowdsale contract upon creation.
  /// @param self Stored crowdsale from crowdsale contract
  /// @param _owner Address of crowdsale owner
  /// @param _saleData Array of 3 item sets such that, in each 3 element
  /// set, 1 is timestamp, 2 is price in cents at that time,
  /// 3 is address purchase cap at that time, 0 if no address cap
  /// @param _fallbackExchangeRate Exchange rate of cents/ETH
  /// @param _capAmountInCents Total to be raised in cents
  /// @param _endTime Timestamp of sale end time
  /// @param _percentBurn Percentage of extra tokens to burn
  /// @param _token Token being sold
  function init(DirectCrowdsaleStorage storage self,
                address _owner,
                uint256[] _saleData,
                uint256 _fallbackExchangeRate,
                uint256 _capAmountInCents,
                uint256 _endTime,
                uint8 _percentBurn,
                CrowdsaleToken _token)
                public
  {
  	self.base.init(_owner,
                _saleData,
                _fallbackExchangeRate,
                _capAmountInCents,
                _endTime,
                _percentBurn,
                _token);
  }

  /// @dev Called when an address wants to purchase tokens
  /// @param self Stored crowdsale from crowdsale contract
  /// @param _amount amount of wei that the buyer is sending
  /// @return true on succesful purchase
  function receivePurchase(DirectCrowdsaleStorage storage self, uint256 _amount)
                           public
                           returns (bool)
  {
    require(msg.sender != self.base.owner);
  	require(self.base.validPurchase());

  	// if the token price increase interval has passed, update the current day and change the token price
  	if ((self.base.milestoneTimes.length > self.base.currentMilestone + 1) &&
        (now > self.base.milestoneTimes[self.base.currentMilestone + 1]))
    {
        while((self.base.milestoneTimes.length > self.base.currentMilestone + 1) &&
              (now > self.base.milestoneTimes[self.base.currentMilestone + 1]))
        {
          self.base.currentMilestone += 1;
        }

        self.base.changeTokenPrice(self.base.saleData[self.base.milestoneTimes[self.base.currentMilestone]][0]);
        LogTokenPriceChange(self.base.tokensPerEth,"Token Price has changed!");
    }

  	uint256 _numTokens; //number of tokens that will be purchased
    uint256 _newBalance; //the new balance of the owner of the crowdsale
    uint256 _weiTokens; //temp calc holder
    uint256 _leftoverWei; //wei change for purchaser
    uint256 _remainder; //temp calc holder
    bool err;

    if((self.base.ownerBalance + _amount) > self.base.capAmount){
      _leftoverWei = (self.base.ownerBalance + _amount) - self.base.capAmount;
      _amount = _amount - _leftoverWei;
    }

    // Find the number of tokens as a function in wei
    (err,_weiTokens) = _amount.times(self.base.tokensPerEth);
    require(!err);

    _numTokens = _weiTokens / 1000000000000000000;
    _remainder = _weiTokens % 1000000000000000000;
    _remainder = _remainder / self.base.tokensPerEth;
    _leftoverWei = _leftoverWei + _remainder;
    _amount = _amount - _remainder;
    self.base.leftoverWei[msg.sender] += _leftoverWei;

    // can't overflow because it is under the cap
    self.base.hasContributed[msg.sender] += _amount;

    assert(_numTokens <= self.base.token.balanceOf(this));

    // calculate the amount of ether in the owners balance
    (err,_newBalance) = self.base.ownerBalance.plus(_amount);
    require(!err);

    self.base.ownerBalance = _newBalance;   // "deposit" the amount

    // can't overflow because it will be under the cap
	  self.base.withdrawTokensMap[msg.sender] += _numTokens;

    //subtract tokens from owner's share
    (err,_remainder) = self.base.withdrawTokensMap[self.base.owner].minus(_numTokens);
    require(!err);
    self.base.withdrawTokensMap[self.base.owner] = _remainder;

	  LogTokensBought(msg.sender, _numTokens);

    return true;
  }

  /*Functions "inherited" from CrowdsaleLib library*/

  function setTokenExchangeRate(DirectCrowdsaleStorage storage self, uint256 _exchangeRate)
                                public
                                returns (bool)
  {
    return self.base.setTokenExchangeRate(_exchangeRate);
  }

  function setTokens(DirectCrowdsaleStorage storage self) public returns (bool) {
    return self.base.setTokens();
  }

  function withdrawTokens(DirectCrowdsaleStorage storage self) public returns (bool) {
    return self.base.withdrawTokens();
  }

  function withdrawLeftoverWei(DirectCrowdsaleStorage storage self) public returns (bool) {
    return self.base.withdrawLeftoverWei();
  }

  function withdrawOwnerEth(DirectCrowdsaleStorage storage self) public returns (bool) {
    return self.base.withdrawOwnerEth();
  }

  function getSaleData(DirectCrowdsaleStorage storage self, uint256 timestamp)
                       public
                       view
                       returns (uint256[3])
  {
    return self.base.getSaleData(timestamp);
  }

  function getTokensSold(DirectCrowdsaleStorage storage self) public view returns (uint256) {
    return self.base.getTokensSold();
  }

  function crowdsaleActive(DirectCrowdsaleStorage storage self) public view returns (bool) {
    return self.base.crowdsaleActive();
  }

  function crowdsaleEnded(DirectCrowdsaleStorage storage self) public view returns (bool) {
    return self.base.crowdsaleEnded();
  }
}

library CrowdsaleLib {
  using BasicMathLib for uint256;

  struct CrowdsaleStorage {
  	address owner;     //owner of the crowdsale

  	uint256 tokensPerEth;  //number of tokens received per ether
  	uint256 capAmount; //Maximum amount to be raised in wei
  	uint256 startTime; //ICO start time, timestamp
  	uint256 endTime; //ICO end time, timestamp automatically calculated
    uint256 exchangeRate; //cents/ETH exchange rate at the time of the sale
    uint256 ownerBalance; //owner wei Balance
    uint256 startingTokenBalance; //initial amount of tokens for sale
    uint256[] milestoneTimes; //Array of timestamps when token price and address cap changes
    uint8 currentMilestone; //Pointer to the current milestone
    uint8 tokenDecimals; //stored token decimals for calculation later
    uint8 percentBurn; //percentage of extra tokens to burn
    bool tokensSet; //true if tokens have been prepared for crowdsale
    bool rateSet; //true if exchange rate has been set

    //Maps timestamp to token price and address purchase cap starting at that time
    mapping (uint256 => uint256[2]) saleData;

    //shows how much wei an address has contributed
  	mapping (address => uint256) hasContributed;

    //For token withdraw function, maps a user address to the amount of tokens they can withdraw
  	mapping (address => uint256) withdrawTokensMap;

    // any leftover wei that buyers contributed that didn't add up to a whole token amount
    mapping (address => uint256) leftoverWei;

  	CrowdsaleToken token; //token being sold
  }

  // Indicates when an address has withdrawn their supply of tokens
  event LogTokensWithdrawn(address indexed _bidder, uint256 Amount);

  // Indicates when an address has withdrawn their supply of extra wei
  event LogWeiWithdrawn(address indexed _bidder, uint256 Amount);

  // Logs when owner has pulled eth
  event LogOwnerEthWithdrawn(address indexed owner, uint256 amount, string Msg);

  // Generic Notice message that includes and address and number
  event LogNoticeMsg(address _buyer, uint256 value, string Msg);

  // Indicates when an error has occurred in the execution of a function
  event LogErrorMsg(uint256 amount, string Msg);

  /// @dev Called by a crowdsale contract upon creation.
  /// @param self Stored crowdsale from crowdsale contract
  /// @param _owner Address of crowdsale owner
  /// @param _saleData Array of 3 item sets such that, in each 3 element
  /// set, 1 is timestamp, 2 is price in cents at that time,
  /// 3 is address token purchase cap at that time, 0 if no address cap
  /// @param _fallbackExchangeRate Exchange rate of cents/ETH
  /// @param _capAmountInCents Total to be raised in cents
  /// @param _endTime Timestamp of sale end time
  /// @param _percentBurn Percentage of extra tokens to burn
  /// @param _token Token being sold
  function init(CrowdsaleStorage storage self,
                address _owner,
                uint256[] _saleData,
                uint256 _fallbackExchangeRate,
                uint256 _capAmountInCents,
                uint256 _endTime,
                uint8 _percentBurn,
                CrowdsaleToken _token)
                public
  {
  	require(self.capAmount == 0);
  	require(self.owner == 0);
    require(_saleData.length > 0);
    require((_saleData.length%3) == 0); // ensure saleData is 3-item sets
    require(_saleData[0] > (now + 3 days));
    require(_endTime > _saleData[0]);
    require(_capAmountInCents > 0);
    require(_owner > 0);
    require(_fallbackExchangeRate > 0);
    require(_percentBurn <= 100);
    self.owner = _owner;
    self.capAmount = ((_capAmountInCents/_fallbackExchangeRate) + 1)*(10**18);
    self.startTime = _saleData[0];
    self.endTime = _endTime;
    self.token = _token;
    self.tokenDecimals = _token.decimals();
    self.percentBurn = _percentBurn;
    self.exchangeRate = _fallbackExchangeRate;

    uint256 _tempTime;
    for(uint256 i = 0; i < _saleData.length; i += 3){
      require(_saleData[i] > _tempTime);
      require(_saleData[i + 1] > 0);
      require((_saleData[i + 2] == 0) || (_saleData[i + 2] >= 100));
      self.milestoneTimes.push(_saleData[i]);
      self.saleData[_saleData[i]][0] = _saleData[i + 1];
      self.saleData[_saleData[i]][1] = _saleData[i + 2];
      _tempTime = _saleData[i];
    }
    changeTokenPrice(self, _saleData[1]);
  }

  /// @dev function to check if the crowdsale is currently active
  /// @param self Stored crowdsale from crowdsale contract
  /// @return success
  function crowdsaleActive(CrowdsaleStorage storage self) public view returns (bool) {
  	return (now >= self.startTime && now <= self.endTime);
  }

  /// @dev function to check if the crowdsale has ended
  /// @param self Stored crowdsale from crowdsale contract
  /// @return success
  function crowdsaleEnded(CrowdsaleStorage storage self) public view returns (bool) {
  	return now > self.endTime;
  }

  /// @dev function to check if a purchase is valid
  /// @param self Stored crowdsale from crowdsale contract
  /// @return true if the transaction can buy tokens
  function validPurchase(CrowdsaleStorage storage self) internal returns (bool) {
    bool nonZeroPurchase = msg.value != 0;
    if (crowdsaleActive(self) && nonZeroPurchase) {
      return true;
    } else {
      LogErrorMsg(msg.value, "Invalid Purchase! Check start time and amount of ether.");
      return false;
    }
  }

  /// @dev Function called by purchasers to pull tokens
  /// @param self Stored crowdsale from crowdsale contract
  /// @return true if tokens were withdrawn
  function withdrawTokens(CrowdsaleStorage storage self) public returns (bool) {
    bool ok;

    if (self.withdrawTokensMap[msg.sender] == 0) {
      LogErrorMsg(0, "Sender has no tokens to withdraw!");
      return false;
    }

    if (msg.sender == self.owner) {
      if(!crowdsaleEnded(self)){
        LogErrorMsg(0, "Owner cannot withdraw extra tokens until after the sale!");
        return false;
      } else {
        if(self.percentBurn > 0){
          uint256 _burnAmount = (self.withdrawTokensMap[msg.sender] * self.percentBurn)/100;
          self.withdrawTokensMap[msg.sender] = self.withdrawTokensMap[msg.sender] - _burnAmount;
          ok = self.token.burnToken(_burnAmount);
          require(ok);
        }
      }
    }

    var total = self.withdrawTokensMap[msg.sender];
    self.withdrawTokensMap[msg.sender] = 0;
    ok = self.token.transfer(msg.sender, total);
    require(ok);
    LogTokensWithdrawn(msg.sender, total);
    return true;
  }

  /// @dev Function called by purchasers to pull leftover wei from their purchases
  /// @param self Stored crowdsale from crowdsale contract
  /// @return true if wei was withdrawn
  function withdrawLeftoverWei(CrowdsaleStorage storage self) public returns (bool) {
    if (self.leftoverWei[msg.sender] == 0) {
      LogErrorMsg(0, "Sender has no extra wei to withdraw!");
      return false;
    }

    var total = self.leftoverWei[msg.sender];
    self.leftoverWei[msg.sender] = 0;
    msg.sender.transfer(total);
    LogWeiWithdrawn(msg.sender, total);
    return true;
  }

  /// @dev send ether from the completed crowdsale to the owners wallet address
  /// @param self Stored crowdsale from crowdsale contract
  /// @return true if owner withdrew eth
  function withdrawOwnerEth(CrowdsaleStorage storage self) public returns (bool) {
    if ((!crowdsaleEnded(self)) && (self.token.balanceOf(this)>0)) {
      LogErrorMsg(0, "Cannot withdraw owner ether until after the sale!");
      return false;
    }

    require(msg.sender == self.owner);
    require(self.ownerBalance > 0);

    uint256 amount = self.ownerBalance;
    self.ownerBalance = 0;
    self.owner.transfer(amount);
    LogOwnerEthWithdrawn(msg.sender,amount,"Crowdsale owner has withdrawn all funds!");

    return true;
  }

  /// @dev Function to change the price of the token
  /// @param self Stored crowdsale from crowdsale contract
  /// @param _newPrice new token price (amount of tokens per ether)
  /// @return true if the token price changed successfully
  function changeTokenPrice(CrowdsaleStorage storage self,
                            uint256 _newPrice)
                            internal
                            returns (bool)
  {
  	require(_newPrice > 0);

    bool err;
    uint256 result;

    (err, result) = self.exchangeRate.times(10**uint256(self.tokenDecimals));
    require(!err);

    self.tokensPerEth = result / _newPrice;

    return true;
  }

  /// @dev function that is called three days before the sale to set the token and price
  /// @param self Stored Crowdsale from crowdsale contract
  /// @param _exchangeRate  ETH exchange rate expressed in cents/ETH
  /// @return true if the exchange rate has been set
  function setTokenExchangeRate(CrowdsaleStorage storage self, uint256 _exchangeRate)
                                public
                                returns (bool)
  {
    require(msg.sender == self.owner);
    require((now > (self.startTime - 3 days)) && (now < (self.startTime)));
    require(!self.rateSet);   // the exchange rate can only be set once!
    require(self.token.balanceOf(this) > 0);
    require(_exchangeRate > 0);

    uint256 _capAmountInCents;
    bool err;

    (err, _capAmountInCents) = self.exchangeRate.times(self.capAmount);
    require(!err);

    self.exchangeRate = _exchangeRate;
    self.capAmount = (_capAmountInCents/_exchangeRate) + 1;
    changeTokenPrice(self,self.saleData[self.milestoneTimes[0]][0]);
    self.rateSet = true;

    err = !(setTokens(self));
    require(!err);

    LogNoticeMsg(msg.sender,self.tokensPerEth,"Owner has set the exchange Rate and tokens bought per ETH!");
    return true;
  }

  /// @dev fallback function to set tokens if the exchange rate function was not called
  /// @param self Stored Crowdsale from crowdsale contract
  /// @return true if tokens set successfully
  function setTokens(CrowdsaleStorage storage self) public returns (bool) {
    require((msg.sender == self.owner) || (msg.sender == address(this)));
    require(!self.tokensSet);

    uint256 _tokenBalance;

    _tokenBalance = self.token.balanceOf(this);
    self.withdrawTokensMap[msg.sender] = _tokenBalance;
    self.startingTokenBalance = _tokenBalance;
    self.tokensSet = true;

    return true;
  }

  /// @dev Gets the price and buy cap for individual addresses at the given milestone index
  /// @param self Stored Crowdsale from crowdsale contract
  /// @param timestamp Time during sale for which data is requested
  /// @return A 3-element array with 0 the timestamp, 1 the price in cents, 2 the address cap
  function getSaleData(CrowdsaleStorage storage self, uint256 timestamp)
                       public
                       view
                       returns (uint256[3])
  {
    uint256[3] memory _thisData;
    uint256 index;

    while((index < self.milestoneTimes.length) && (self.milestoneTimes[index] < timestamp)) {
      index++;
    }
    if(index == 0)
      index++;

    _thisData[0] = self.milestoneTimes[index - 1];
    _thisData[1] = self.saleData[_thisData[0]][0];
    _thisData[2] = self.saleData[_thisData[0]][1];
    return _thisData;
  }

  /// @dev Gets the number of tokens sold thus far
  /// @param self Stored Crowdsale from crowdsale contract
  /// @return Number of tokens sold
  function getTokensSold(CrowdsaleStorage storage self) public view returns (uint256) {
    return self.startingTokenBalance - self.token.balanceOf(this);
  }
}

library TokenLib {
  using BasicMathLib for uint256;

  struct TokenStorage {
    bool initialized;
    mapping (address => uint256) balances;
    mapping (address => mapping (address => uint256)) allowed;

    string name;
    string symbol;
    uint256 totalSupply;
    uint256 initialSupply;
    address owner;
    uint8 decimals;
    bool stillMinting;
  }

  event Transfer(address indexed from, address indexed to, uint256 value);
  event Approval(address indexed owner, address indexed spender, uint256 value);
  event OwnerChange(address from, address to);
  event Burn(address indexed burner, uint256 value);
  event MintingClosed(bool mintingClosed);

  /// @dev Called by the Standard Token upon creation.
  /// @param self Stored token from token contract
  /// @param _name Name of the new token
  /// @param _symbol Symbol of the new token
  /// @param _decimals Decimal places for the token represented
  /// @param _initial_supply The initial token supply
  /// @param _allowMinting True if additional tokens can be created, false otherwise
  function init(TokenStorage storage self,
                address _owner,
                string _name,
                string _symbol,
                uint8 _decimals,
                uint256 _initial_supply,
                bool _allowMinting)
                public
  {
    require(!self.initialized);
    self.initialized = true;
    self.name = _name;
    self.symbol = _symbol;
    self.totalSupply = _initial_supply;
    self.initialSupply = _initial_supply;
    self.decimals = _decimals;
    self.owner = _owner;
    self.stillMinting = _allowMinting;
    self.balances[_owner] = _initial_supply;
  }

  /// @dev Transfer tokens from caller's account to another account.
  /// @param self Stored token from token contract
  /// @param _to Address to send tokens
  /// @param _value Number of tokens to send
  /// @return True if completed
  function transfer(TokenStorage storage self, address _to, uint256 _value) public returns (bool) {
    require(_to != address(0));
    bool err;
    uint256 balance;

    (err,balance) = self.balances[msg.sender].minus(_value);
    require(!err);
    self.balances[msg.sender] = balance;
    //It's not possible to overflow token supply
    self.balances[_to] = self.balances[_to] + _value;
    Transfer(msg.sender, _to, _value);
    return true;
  }

  /// @dev Authorized caller transfers tokens from one account to another
  /// @param self Stored token from token contract
  /// @param _from Address to send tokens from
  /// @param _to Address to send tokens to
  /// @param _value Number of tokens to send
  /// @return True if completed
  function transferFrom(TokenStorage storage self,
                        address _from,
                        address _to,
                        uint256 _value)
                        public
                        returns (bool)
  {
    var _allowance = self.allowed[_from][msg.sender];
    bool err;
    uint256 balanceOwner;
    uint256 balanceSpender;

    (err,balanceOwner) = self.balances[_from].minus(_value);
    require(!err);

    (err,balanceSpender) = _allowance.minus(_value);
    require(!err);

    self.balances[_from] = balanceOwner;
    self.allowed[_from][msg.sender] = balanceSpender;
    self.balances[_to] = self.balances[_to] + _value;

    Transfer(_from, _to, _value);
    return true;
  }

  /// @dev Retrieve token balance for an account
  /// @param self Stored token from token contract
  /// @param _owner Address to retrieve balance of
  /// @return balance The number of tokens in the subject account
  function balanceOf(TokenStorage storage self, address _owner) public view returns (uint256 balance) {
    return self.balances[_owner];
  }

  /// @dev Authorize an account to send tokens on caller's behalf
  /// @param self Stored token from token contract
  /// @param _spender Address to authorize
  /// @param _value Number of tokens authorized account may send
  /// @return True if completed
  function approve(TokenStorage storage self, address _spender, uint256 _value) public returns (bool) {
    // must set to zero before changing approval amount in accordance with spec
    require((_value == 0) || (self.allowed[msg.sender][_spender] == 0));

    self.allowed[msg.sender][_spender] = _value;
    Approval(msg.sender, _spender, _value);
    return true;
  }

  /// @dev Remaining tokens third party spender has to send
  /// @param self Stored token from token contract
  /// @param _owner Address of token holder
  /// @param _spender Address of authorized spender
  /// @return remaining Number of tokens spender has left in owner's account
  function allowance(TokenStorage storage self, address _owner, address _spender)
                     public
                     view
                     returns (uint256 remaining) {
    return self.allowed[_owner][_spender];
  }

  /// @dev Authorize third party transfer by increasing/decreasing allowed rather than setting it
  /// @param self Stored token from token contract
  /// @param _spender Address to authorize
  /// @param _valueChange Increase or decrease in number of tokens authorized account may send
  /// @param _increase True if increasing allowance, false if decreasing allowance
  /// @return True if completed
  function approveChange (TokenStorage storage self, address _spender, uint256 _valueChange, bool _increase)
                          public returns (bool)
  {
    uint256 _newAllowed;
    bool err;

    if(_increase) {
      (err, _newAllowed) = self.allowed[msg.sender][_spender].plus(_valueChange);
      require(!err);

      self.allowed[msg.sender][_spender] = _newAllowed;
    } else {
      if (_valueChange > self.allowed[msg.sender][_spender]) {
        self.allowed[msg.sender][_spender] = 0;
      } else {
        _newAllowed = self.allowed[msg.sender][_spender] - _valueChange;
        self.allowed[msg.sender][_spender] = _newAllowed;
      }
    }

    Approval(msg.sender, _spender, _newAllowed);
    return true;
  }

  /// @dev Change owning address of the token contract, specifically for minting
  /// @param self Stored token from token contract
  /// @param _newOwner Address for the new owner
  /// @return True if completed
  function changeOwner(TokenStorage storage self, address _newOwner) public returns (bool) {
    require((self.owner == msg.sender) && (_newOwner > 0));

    self.owner = _newOwner;
    OwnerChange(msg.sender, _newOwner);
    return true;
  }

  /// @dev Mints additional tokens, new tokens go to owner
  /// @param self Stored token from token contract
  /// @param _amount Number of tokens to mint
  /// @return True if completed
  function mintToken(TokenStorage storage self, uint256 _amount) public returns (bool) {
    require((self.owner == msg.sender) && self.stillMinting);
    uint256 _newAmount;
    bool err;

    (err, _newAmount) = self.totalSupply.plus(_amount);
    require(!err);

    self.totalSupply =  _newAmount;
    self.balances[self.owner] = self.balances[self.owner] + _amount;
    Transfer(0x0, self.owner, _amount);
    return true;
  }

  /// @dev Permanent stops minting
  /// @param self Stored token from token contract
  /// @return True if completed
  function closeMint(TokenStorage storage self) public returns (bool) {
    require(self.owner == msg.sender);

    self.stillMinting = false;
    MintingClosed(true);
    return true;
  }

  /// @dev Permanently burn tokens
  /// @param self Stored token from token contract
  /// @param _amount Amount of tokens to burn
  /// @return True if completed
  function burnToken(TokenStorage storage self, uint256 _amount) public returns (bool) {
      uint256 _newBalance;
      bool err;

      (err, _newBalance) = self.balances[msg.sender].minus(_amount);
      require(!err);

      self.balances[msg.sender] = _newBalance;
      self.totalSupply = self.totalSupply - _amount;
      Burn(msg.sender, _amount);
      Transfer(msg.sender, 0x0, _amount);
      return true;
  }
}

library BasicMathLib {
  /// @dev Multiplies two numbers and checks for overflow before returning.
  /// Does not throw.
  /// @param a First number
  /// @param b Second number
  /// @return err False normally, or true if there is overflow
  /// @return res The product of a and b, or 0 if there is overflow
  function times(uint256 a, uint256 b) public view returns (bool err,uint256 res) {
    assembly{
      res := mul(a,b)
      switch or(iszero(b), eq(div(res,b), a))
      case 0 {
        err := 1
        res := 0
      }
    }
  }

  /// @dev Divides two numbers but checks for 0 in the divisor first.
  /// Does not throw.
  /// @param a First number
  /// @param b Second number
  /// @return err False normally, or true if `b` is 0
  /// @return res The quotient of a and b, or 0 if `b` is 0
  function dividedBy(uint256 a, uint256 b) public view returns (bool err,uint256 i) {
    uint256 res;
    assembly{
      switch iszero(b)
      case 0 {
        res := div(a,b)
        let loc := mload(0x40)
        mstore(add(loc,0x20),res)
        i := mload(add(loc,0x20))
      }
      default {
        err := 1
        i := 0
      }
    }
  }

  /// @dev Adds two numbers and checks for overflow before returning.
  /// Does not throw.
  /// @param a First number
  /// @param b Second number
  /// @return err False normally, or true if there is overflow
  /// @return res The sum of a and b, or 0 if there is overflow
  function plus(uint256 a, uint256 b) public view returns (bool err, uint256 res) {
    assembly{
      res := add(a,b)
      switch and(eq(sub(res,b), a), or(gt(res,b),eq(res,b)))
      case 0 {
        err := 1
        res := 0
      }
    }
  }

  /// @dev Subtracts two numbers and checks for underflow before returning.
  /// Does not throw but rather logs an Err event if there is underflow.
  /// @param a First number
  /// @param b Second number
  /// @return err False normally, or true if there is underflow
  /// @return res The difference between a and b, or 0 if there is underflow
  function minus(uint256 a, uint256 b) public view returns (bool err,uint256 res) {
    assembly{
      res := sub(a,b)
      switch eq(and(eq(add(res,b), a), or(lt(res,a), eq(res,a))), 1)
      case 0 {
        err := 1
        res := 0
      }
    }
  }
}

contract CrowdsaleToken {
  using TokenLib for TokenLib.TokenStorage;

  TokenLib.TokenStorage public token;

  function CrowdsaleToken(address owner,
                                   string name,
                                   string symbol,
                                   uint8 decimals,
                                   uint256 initialSupply,
                                   bool allowMinting)
                                   public
  {
    token.init(owner, name, symbol, decimals, initialSupply, allowMinting);
  }

  function name() public view returns (string) {
    return token.name;
  }

  function symbol() public view returns (string) {
    return token.symbol;
  }

  function decimals() public view returns (uint8) {
    return token.decimals;
  }

  function totalSupply() public view returns (uint256) {
    return token.totalSupply;
  }

  function initialSupply() public view returns (uint256) {
    return token.initialSupply;
  }

  function balanceOf(address who) public view returns (uint256) {
    return token.balanceOf(who);
  }

  function allowance(address owner, address spender) public view returns (uint256) {
    return token.allowance(owner, spender);
  }

  function transfer(address to, uint256 value) public returns (bool ok) {
    return token.transfer(to, value);
  }

  function transferFrom(address from, address to, uint value) public returns (bool ok) {
    return token.transferFrom(from, to, value);
  }

  function approve(address spender, uint256 value) public returns (bool ok) {
    return token.approve(spender, value);
  }

  function approveChange(address spender, uint256 valueChange, bool increase)
                         public
                         returns (bool)
  {
    return token.approveChange(spender, valueChange, increase);
  }

  function changeOwner(address newOwner) public returns (bool ok) {
    return token.changeOwner(newOwner);
  }

  function burnToken(uint256 amount) public returns (bool ok) {
    return token.burnToken(amount);
  }
}

Contract ABI
[{"constant":true,"inputs":[],"name":"crowdsaleActive","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"withdrawOwnerEth","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"_buyer","type":"address"}],"name":"getContribution","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"crowdsaleEnded","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"getEthRaised","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"greenshoeActive","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_buyer","type":"address"}],"name":"getLeftoverWei","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"getEndTime","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"setTokens","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"sendPurchase","outputs":[{"name":"","type":"bool"}],"payable":true,"stateMutability":"payable","type":"function"},{"constant":true,"inputs":[],"name":"getTokensPerEth","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"timestamp","type":"uint256"}],"name":"getSaleData","outputs":[{"name":"","type":"uint256[3]"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"getOwner","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"withdrawTokens","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"withdrawLeftoverWei","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"getPercentBurn","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"getStartTime","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_exchangeRate","type":"uint256"}],"name":"setTokenExchangeRate","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"getCapAmount","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"getExchangeRate","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"getTokensSold","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_buyer","type":"address"}],"name":"getTokenPurchase","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"inputs":[{"name":"owner","type":"address"},{"name":"saleData","type":"uint256[]"},{"name":"fallbackExchangeRate","type":"uint256"},{"name":"capAmountInCents","type":"uint256"},{"name":"endTime","type":"uint256"},{"name":"percentBurn","type":"uint8"},{"name":"token","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"payable":true,"stateMutability":"payable","type":"fallback"}]

Contract Creation Code
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


    Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
00000000000000000000000058f75ddacffb183a30f69fe58a67a0d0985fce0f00000000000000000000000000000000000000000000000000000000000000e0000000000000000000000000000000000000000000000000000000000000afc800000000000000000000000000000000000000000000000000000005c3370780000000000000000000000000000000000000000000000000000000005a4ddec4000000000000000000000000000000000000000000000000000000000000006400000000000000000000000080bc5512561c7f85a3a9508c7df7901b370fa1df000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000005a28f50000000000000000000000000000000000000000000000000000000000000000320000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005a322f8000000000000000000000000000000000000000000000000000000000000000380000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005a3b6a0000000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005a44a480000000000000000000000000000000000000000000000000000000000000004b0000000000000000000000000000000000000000000000000000000000000000

-----Encoded View---------------
20 Constructor Arguments found :
Arg [0] : 00000000000000000000000058f75ddacffb183a30f69fe58a67a0d0985fce0f
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000e0
Arg [2] : 000000000000000000000000000000000000000000000000000000000000afc8
Arg [3] : 00000000000000000000000000000000000000000000000000000005c3370780
Arg [4] : 000000000000000000000000000000000000000000000000000000005a4ddec4
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000064
Arg [6] : 00000000000000000000000080bc5512561c7f85a3a9508c7df7901b370fa1df
Arg [7] : 000000000000000000000000000000000000000000000000000000000000000c
Arg [8] : 000000000000000000000000000000000000000000000000000000005a28f500
Arg [9] : 0000000000000000000000000000000000000000000000000000000000000032
Arg [10] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [11] : 000000000000000000000000000000000000000000000000000000005a322f80
Arg [12] : 0000000000000000000000000000000000000000000000000000000000000038
Arg [13] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [14] : 000000000000000000000000000000000000000000000000000000005a3b6a00
Arg [15] : 0000000000000000000000000000000000000000000000000000000000000040
Arg [16] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [17] : 000000000000000000000000000000000000000000000000000000005a44a480
Arg [18] : 000000000000000000000000000000000000000000000000000000000000004b
Arg [19] : 0000000000000000000000000000000000000000000000000000000000000000


   Library Used
DirectCrowdsaleLib : 0x8F43b453f187658e9519b04AC221ebc9478218c4

   Swarm Source:
bzzr://1a78412ddf052c99c7aa46ecf45ef347e95f68216e1fee040367ff3fc9c55fb7
Block Age transaction Difficulty GasUsed Reward
Block Age Uncle Number Difficulty GasUsed Reward
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.