Contract 0x2D68a9A9dD9fcFFB070EA1d8218c67863bFC55Ff

 
 
Txn Hash
Method
Block
From
To
Value
0x34a72eeaf2511f3b2ad98498618e442311f456cc2a353226446b37e477090a25Finalize42384472017-09-04 19:03:511920 days 34 mins ago0x70775e3d54557738392469aa032148995e08d190 IN  0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff0 Ether0.0014177827.22106332
0x98621add46873756820c600a788f7f713414e77194a3ed2ebf9faddc52e6d720Transfer42204512017-08-30 16:44:021925 days 2 hrs ago0x6ba6ecc1e4de4234dcb76c51624dce74848b061e IN  0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff11.642 Ether0.006425750
0xaa6d4f9ac3309f492522eb8b45fdc513808a2c030440c0a37c4355ba5cfea5c0Transfer42204452017-08-30 16:42:041925 days 2 hrs ago0x6ba6ecc1e4de4234dcb76c51624dce74848b061e IN  0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff11.642 Ether0.00550
0x0c89d409ac9e7918e18c4410edde71abf9623c1e0d2b13f5bfc89dcd619fda40Transfer42186252017-08-30 3:55:391925 days 15 hrs ago0xb93f4d1d100d3e1ba272fcd84228044ff9b2a42f IN  0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff10.1 Ether0.0026987921
0x609508b2b08cd5362efd60e3a4919004885df1e78df2dc5bcba7ebd3c86f5c9bTransfer42186062017-08-30 3:47:581925 days 15 hrs ago0x0ddf37b5fe28ac6f4ba3a5a77a809545221131e8 IN  0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff10.01 Ether0.0026987921
0x02dbcb84c7eb29c6faf83a886db08315223d3497d07b147cf6e1cf86b22c2c95Transfer42174322017-08-29 20:02:101925 days 23 hrs ago0x0c69da0ba097e031678ccc826f64f620b98a3528 IN  0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff12 Ether0.0069987660
0xa6d3560f54fb3319ab7b975976693cbd76e65bcb02aba3dc2055c9c24aa2b0ceTransfer42172752017-08-29 18:47:031926 days 51 mins ago0xd78ee7ff1652c318af36dea2faaa9958694e2cdb IN  0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff10 Ether0.0026987921
0xb60063294524ef911b0e7143ee825b247b2c710f5041b0a6245843a51f5fd2c8Transfer42169952017-08-29 16:57:511926 days 2 hrs ago0x0c69da0ba097e031678ccc826f64f620b98a3528 IN  0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff10 Ether0.0069987660
0xb36ea94b820cc38d6f34fa309d46adbca614a1fc56e2d9fa493a8560b83d6f70Transfer42163882017-08-29 12:50:251926 days 6 hrs ago0x4b5cbead0446c999886ef6099cb3b4556a56fe26 IN  0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff25 Ether0.000816527
0xf6d45c9959f5a4fc7aa55ce5b188dc53d2c81071ef78dbb8475eedf54022e4c2Transfer42157892017-08-29 8:53:031926 days 10 hrs ago0x006fc5a99f92bf112d4bf28962209d5e5bef635d IN  0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff10 Ether0.0025702820
0x41c1fa964dda153689205e09608554d46c5017ebc0e24b05e094cc41bdb70782Transfer42157722017-08-29 8:44:371926 days 10 hrs ago0x796fb26afca6031ae839e41cf6015be026893e8c IN  0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff24.2 Ether0.0026987921
0x9f3b7b07a3815040c9d1e2df37a778287dd38c2f8d251d8c4c0505c25cf0fe53Transfer42157622017-08-29 8:40:331926 days 10 hrs ago0x00b703a1d10049d55c7baaf7a5fd102659002793 IN  0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff141 Ether0.0026987921
0xd80c55d5419776baca24591336350ed5f28dbc46c7367e9ffbd02cd0c4ef8311Transfer42157492017-08-29 8:34:001926 days 11 hrs ago0xf15b5f32f2aebd464caeb83004880440916acd1f IN  0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff10 Ether0.002158921
0x495605c4fa3f2adcb17076ef1398b3260f4c6581be38da7ab88f262a846481afTransfer42157492017-08-29 8:34:001926 days 11 hrs ago0xe3576e7e1bee96964dc982ffce25288129132d23 IN  0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff13 Ether0.0026987921
0x619d892b4763b1183e11089d3eb40a288ab8b4d106cdcefc05772adb0e331e2aTransfer42157342017-08-29 8:27:061926 days 11 hrs ago0x88884e35d7006ae84efef09ee6bc6a43dd8e2bb8 IN  0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff10.05 Ether0.0026987921
0xb5487a7ab290c8771fdea4e55a35279f8fc436a898655f265220b6c295932f64Transfer42157272017-08-29 8:24:511926 days 11 hrs ago0x2ae9fa81da01b24179fd7a628bea93a1d9801370 IN  0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff33.3 Ether0.000771086
0xf1c66c2889755ad5180144293788fbe8eae9d881130d3994f2d6e474427ac523Transfer42156952017-08-29 8:13:361926 days 11 hrs ago0x23be8babc65a1c1d3a320cc90a7dff1f48e37153 IN  0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff0.35 Ether0.004221
0xc710b8d66a36b7d4ca16063454c53ddde26d85ad1d3c7d6838c844e825e69a12Transfer42156472017-08-29 7:56:181926 days 11 hrs ago0x5af5ef835d3c4d574770899baf7ff16a48b5ee2e IN  0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff10 Ether0.006425750
0x705f324d48ebcdf3b664d63eb6d9b31777ebbea3d802988fc9386587994b99f7Transfer42156202017-08-29 7:48:151926 days 11 hrs ago0xd612189ddc5e50c603cfe4521df8a762d7c0a9db IN  0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff60 Ether0.0023329220
0x914d54b5f946f09d3db853b7d23265e2727d116e03a9827a14a6770af5758008Transfer42155172017-08-29 7:09:121926 days 12 hrs ago0x57b8581af0b271cc74d724f6dbccb3fb724eb1ea IN  0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff10.5 Ether0.001028118
0x633110c9cbdd098accf7563383c114112b7ca32eedc2ac76ccb13019a29533f1Transfer42154442017-08-29 6:27:531926 days 13 hrs ago0x50eea03e975d6b308a9264a8cef4d90e52803875 IN  0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff10.9 Ether0.006425750
0xe3ada0aa114f642388939b3a1321defcc081f92bbd6b3c68c9f0393964842bdcTransfer42154142017-08-29 6:17:311926 days 13 hrs ago0xf22bf01a1a2f27c8d530252da89007ac79a52143 IN  0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff0.13459861 Ether0.004221
0x29cd69237f59dbfb2d986cf79c12996e4b5046985633a62919fdcdacf949594fTransfer42153102017-08-29 5:38:131926 days 14 hrs ago0x617d5868b434067debdeedec9ca04d1a863e5b99 IN  0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff12 Ether0.0026987921
0xb346fce36d2a76e511bb835499497cf76693fc2c48829c260d4b0e290d94b355Transfer42153072017-08-29 5:35:381926 days 14 hrs ago0xd7774361b8e25e3fffc92b7cdbeed3778b678076 IN  0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff10.5 Ether0.0032815125.53433561
0xabd7151e4e9d1b8e6cda038c1de11840775db5673921670eb9189757e06818e1Transfer42152762017-08-29 5:23:321926 days 14 hrs ago0x1446176e35fd13e70b832d29b93d1040d5bd1cb2 IN  0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff10.99166769 Ether0.0026987921
[ Download CSV Export 
Latest 25 internal transaction
Parent Txn Hash Block From To Value
0x98621add46873756820c600a788f7f713414e77194a3ed2ebf9faddc52e6d72042204512017-08-30 16:44:021925 days 2 hrs ago 0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff 0x1d9776c22b8790009f12927386c1e27da45fe1f311.642 Ether
0x0c89d409ac9e7918e18c4410edde71abf9623c1e0d2b13f5bfc89dcd619fda4042186252017-08-30 3:55:391925 days 15 hrs ago 0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff 0x1d9776c22b8790009f12927386c1e27da45fe1f310.1 Ether
0x609508b2b08cd5362efd60e3a4919004885df1e78df2dc5bcba7ebd3c86f5c9b42186062017-08-30 3:47:581925 days 15 hrs ago 0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff 0x1d9776c22b8790009f12927386c1e27da45fe1f310.01 Ether
0x02dbcb84c7eb29c6faf83a886db08315223d3497d07b147cf6e1cf86b22c2c9542174322017-08-29 20:02:101925 days 23 hrs ago 0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff 0x1d9776c22b8790009f12927386c1e27da45fe1f312 Ether
0xa6d3560f54fb3319ab7b975976693cbd76e65bcb02aba3dc2055c9c24aa2b0ce42172752017-08-29 18:47:031926 days 51 mins ago 0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff 0x1d9776c22b8790009f12927386c1e27da45fe1f310 Ether
0xb60063294524ef911b0e7143ee825b247b2c710f5041b0a6245843a51f5fd2c842169952017-08-29 16:57:511926 days 2 hrs ago 0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff 0x1d9776c22b8790009f12927386c1e27da45fe1f310 Ether
0xb36ea94b820cc38d6f34fa309d46adbca614a1fc56e2d9fa493a8560b83d6f7042163882017-08-29 12:50:251926 days 6 hrs ago 0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff 0x1d9776c22b8790009f12927386c1e27da45fe1f325 Ether
0xf6d45c9959f5a4fc7aa55ce5b188dc53d2c81071ef78dbb8475eedf54022e4c242157892017-08-29 8:53:031926 days 10 hrs ago 0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff 0x1d9776c22b8790009f12927386c1e27da45fe1f310 Ether
0x41c1fa964dda153689205e09608554d46c5017ebc0e24b05e094cc41bdb7078242157722017-08-29 8:44:371926 days 10 hrs ago 0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff 0x1d9776c22b8790009f12927386c1e27da45fe1f324.2 Ether
0x9f3b7b07a3815040c9d1e2df37a778287dd38c2f8d251d8c4c0505c25cf0fe5342157622017-08-29 8:40:331926 days 10 hrs ago 0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff 0x1d9776c22b8790009f12927386c1e27da45fe1f3141 Ether
0xd80c55d5419776baca24591336350ed5f28dbc46c7367e9ffbd02cd0c4ef831142157492017-08-29 8:34:001926 days 11 hrs ago 0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff 0x1d9776c22b8790009f12927386c1e27da45fe1f310 Ether
0x495605c4fa3f2adcb17076ef1398b3260f4c6581be38da7ab88f262a846481af42157492017-08-29 8:34:001926 days 11 hrs ago 0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff 0x1d9776c22b8790009f12927386c1e27da45fe1f313 Ether
0x619d892b4763b1183e11089d3eb40a288ab8b4d106cdcefc05772adb0e331e2a42157342017-08-29 8:27:061926 days 11 hrs ago 0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff 0x1d9776c22b8790009f12927386c1e27da45fe1f310.05 Ether
0xb5487a7ab290c8771fdea4e55a35279f8fc436a898655f265220b6c295932f6442157272017-08-29 8:24:511926 days 11 hrs ago 0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff 0x1d9776c22b8790009f12927386c1e27da45fe1f333.3 Ether
0xc710b8d66a36b7d4ca16063454c53ddde26d85ad1d3c7d6838c844e825e69a1242156472017-08-29 7:56:181926 days 11 hrs ago 0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff 0x1d9776c22b8790009f12927386c1e27da45fe1f310 Ether
0x705f324d48ebcdf3b664d63eb6d9b31777ebbea3d802988fc9386587994b99f742156202017-08-29 7:48:151926 days 11 hrs ago 0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff 0x1d9776c22b8790009f12927386c1e27da45fe1f360 Ether
0x914d54b5f946f09d3db853b7d23265e2727d116e03a9827a14a6770af575800842155172017-08-29 7:09:121926 days 12 hrs ago 0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff 0x1d9776c22b8790009f12927386c1e27da45fe1f310.5 Ether
0x633110c9cbdd098accf7563383c114112b7ca32eedc2ac76ccb13019a29533f142154442017-08-29 6:27:531926 days 13 hrs ago 0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff 0x1d9776c22b8790009f12927386c1e27da45fe1f310.9 Ether
0x29cd69237f59dbfb2d986cf79c12996e4b5046985633a62919fdcdacf949594f42153102017-08-29 5:38:131926 days 14 hrs ago 0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff 0x1d9776c22b8790009f12927386c1e27da45fe1f312 Ether
0xb346fce36d2a76e511bb835499497cf76693fc2c48829c260d4b0e290d94b35542153072017-08-29 5:35:381926 days 14 hrs ago 0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff 0x1d9776c22b8790009f12927386c1e27da45fe1f310.5 Ether
0xabd7151e4e9d1b8e6cda038c1de11840775db5673921670eb9189757e06818e142152762017-08-29 5:23:321926 days 14 hrs ago 0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff 0x1d9776c22b8790009f12927386c1e27da45fe1f310.99166769 Ether
0xec929737a873498f94ab1e3e9c667660e8fe96fea2edb072f4438c38caa206b142150272017-08-29 3:39:351926 days 15 hrs ago 0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff 0x1d9776c22b8790009f12927386c1e27da45fe1f314 Ether
0xc227db7e64f65b2e3679e9b76e5934f0820ed6e8e5925b5ef2eff79cbcbec89442149932017-08-29 3:23:301926 days 16 hrs ago 0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff 0x1d9776c22b8790009f12927386c1e27da45fe1f317.5 Ether
0x46b6c621724bde9e38e15186d1ca720082ffee7323aa17d9dac48d480dbfd4ce42149322017-08-29 2:59:561926 days 16 hrs ago 0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff 0x1d9776c22b8790009f12927386c1e27da45fe1f320 Ether
0xe9527eb31a9a35b45d273b1a73455e1bc10cf9c5d7c3aac5813ac8f57e930e8042149262017-08-29 2:58:061926 days 16 hrs ago 0x2d68a9a9dd9fcffb070ea1d8218c67863bfc55ff 0x1d9776c22b8790009f12927386c1e27da45fe1f322 Ether
[ Download CSV Export 
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
PreSale

Compiler Version
v0.4.11+commit.68ef5810

Optimization Enabled:
No with 200 runs

Other Settings:
default evmVersion

Contract Source Code (Solidity)

/**
 *Submitted for verification at Etherscan.io on 2017-07-23
*/

pragma solidity ^0.4.11;

/*
    Copyright 2017, Klaus Hott
    Copyright 2016, Jordi Baylina

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

/// @title MiniMeToken Contract
/// @author Jordi Baylina
/// @dev This token contract's goal is to make it easy for anyone to clone this
///  token using the token distribution at a given block, this will allow DAO's
///  and DApps to upgrade their features in a decentralized manner without
///  affecting the original token
/// @dev It is ERC20 compliant, but still needs to under go further testing.

contract ERC20 {
  /// @notice Send `_amount` tokens to `_to` from `msg.sender`
  /// @param _to The address of the recipient
  /// @param _amount The amount of tokens to be transferred
  /// @return Whether the transfer was successful or not
  function transfer(address _to, uint256 _amount) returns (bool success);

  /// @notice Send `_amount` tokens to `_to` from `_from` on the condition it
  ///  is approved by `_from`
  /// @param _from The address holding the tokens being transferred
  /// @param _to The address of the recipient
  /// @param _amount The amount of tokens to be transferred
  /// @return True if the transfer was successful
  function transferFrom(address _from, address _to, uint256 _amount
  ) returns (bool success);

  /// @param _owner The address that's balance is being requested
  /// @return The balance of `_owner` at the current block
  function balanceOf(address _owner) constant returns (uint256 balance);

  /// @notice `msg.sender` approves `_spender` to spend `_amount` tokens on
  ///  its behalf. This is a modified version of the ERC20 approve function
  ///  to be a little bit safer
  /// @param _spender The address of the account able to transfer the tokens
  /// @param _amount The amount of tokens to be approved for transfer
  /// @return True if the approval was successful
  function approve(address _spender, uint256 _amount) returns (bool success);

  /// @dev This function makes it easy to read the `allowed[]` map
  /// @param _owner The address of the account that owns the token
  /// @param _spender The address of the account able to transfer the tokens
  /// @return Amount of remaining tokens of _owner that _spender is allowed
  ///  to spend
  function allowance(address _owner, address _spender
  ) constant returns (uint256 remaining);

  /// @notice `msg.sender` approves `_spender` to send `_amount` tokens on
  ///  its behalf, and then a function is triggered in the contract that is
  ///  being approved, `_spender`. This allows users to use their tokens to
  ///  interact with contracts in one function call instead of two
  /// @param _spender The address of the contract able to transfer the tokens
  /// @param _amount The amount of tokens to be approved for transfer
  /// @return True if the function call was successful
  function approveAndCall(address _spender, uint256 _amount, bytes _extraData
  ) returns (bool success);

  /// @dev This function makes it easy to get the total number of tokens
  /// @return The total number of tokens
  function totalSupply() constant returns (uint);
}


/// @dev The token controller contract must implement these functions
contract TokenController {
    /// @notice Called when `_owner` sends ether to the MiniMe Token contract
    /// @param _owner The address that sent the ether to create tokens
    /// @return True if the ether is accepted, false if it throws
    function proxyPayment(address _owner) payable returns(bool);

    /// @notice Notifies the controller about a token transfer allowing the
    ///  controller to react if desired
    /// @param _from The origin of the transfer
    /// @param _to The destination of the transfer
    /// @param _amount The amount of the transfer
    /// @return False if the controller does not authorize the transfer
    function onTransfer(address _from, address _to, uint _amount) returns(bool);

    /// @notice Notifies the controller about an approval allowing the
    ///  controller to react if desired
    /// @param _owner The address that calls `approve()`
    /// @param _spender The spender in the `approve()` call
    /// @param _amount The amount in the `approve()` call
    /// @return False if the controller does not authorize the approval
    function onApprove(address _owner, address _spender, uint _amount)
        returns(bool);
}

contract Controlled {
    /// @notice The address of the controller is the only address that can call
    ///  a function with this modifier
    modifier onlyController { if (msg.sender != controller) throw; _; }

    address public controller;

    function Controlled() { controller = msg.sender;}

    /// @notice Changes the controller of the contract
    /// @param _newController The new controller of the contract
    function changeController(address _newController) onlyController {
        controller = _newController;
    }
}

contract ApproveAndCallFallBack {
    function receiveApproval(address from, uint256 _amount, address _token, bytes _data);
}

/// @dev The actual token contract, the default controller is the msg.sender
///  that deploys the contract, so usually this token will be deployed by a
///  token controller contract, which Giveth will call a "Campaign"
contract MiniMeToken is Controlled {

    string public name;                //The Token's name: e.g. DigixDAO Tokens
    uint8 public decimals;             //Number of decimals of the smallest unit
    string public symbol;              //An identifier: e.g. REP
    string public version = 'MMT_0.1'; //An arbitrary versioning scheme


    /// @dev `Checkpoint` is the structure that attaches a block number to a
    ///  given value, the block number attached is the one that last changed the
    ///  value
    struct  Checkpoint {

        // `fromBlock` is the block number that the value was generated from
        uint128 fromBlock;

        // `value` is the amount of tokens at a specific block number
        uint128 value;
    }

    // `parentToken` is the Token address that was cloned to produce this token;
    //  it will be 0x0 for a token that was not cloned
    MiniMeToken public parentToken;

    // `parentSnapShotBlock` is the block number from the Parent Token that was
    //  used to determine the initial distribution of the Clone Token
    uint public parentSnapShotBlock;

    // `creationBlock` is the block number that the Clone Token was created
    uint public creationBlock;

    // `balances` is the map that tracks the balance of each address, in this
    //  contract when the balance changes the block number that the change
    //  occurred is also included in the map
    mapping (address => Checkpoint[]) balances;

    // `allowed` tracks any extra transfer rights as in all ERC20 tokens
    mapping (address => mapping (address => uint256)) allowed;

    // Tracks the history of the `totalSupply` of the token
    Checkpoint[] totalSupplyHistory;

    // Flag that determines if the token is transferable or not.
    bool public transfersEnabled;

    // The factory used to create new clone tokens
    MiniMeTokenFactory public tokenFactory;

////////////////
// Constructor
////////////////

    /// @notice Constructor to create a MiniMeToken
    /// @param _tokenFactory The address of the MiniMeTokenFactory contract that
    ///  will create the Clone token contracts, the token factory needs to be
    ///  deployed first
    /// @param _parentToken Address of the parent token, set to 0x0 if it is a
    ///  new token
    /// @param _parentSnapShotBlock Block of the parent token that will
    ///  determine the initial distribution of the clone token, set to 0 if it
    ///  is a new token
    /// @param _tokenName Name of the new token
    /// @param _decimalUnits Number of decimals of the new token
    /// @param _tokenSymbol Token Symbol for the new token
    /// @param _transfersEnabled If true, tokens will be able to be transferred
    function MiniMeToken(
        address _tokenFactory,
        address _parentToken,
        uint _parentSnapShotBlock,
        string _tokenName,
        uint8 _decimalUnits,
        string _tokenSymbol,
        bool _transfersEnabled
    ) {
        tokenFactory = MiniMeTokenFactory(_tokenFactory);
        name = _tokenName;                                 // Set the name
        decimals = _decimalUnits;                          // Set the decimals
        symbol = _tokenSymbol;                             // Set the symbol
        parentToken = MiniMeToken(_parentToken);
        parentSnapShotBlock = _parentSnapShotBlock;
        transfersEnabled = _transfersEnabled;
        creationBlock = block.number;
    }


///////////////////
// ERC20 Methods
///////////////////

    /// @notice Send `_amount` tokens to `_to` from `msg.sender`
    /// @param _to The address of the recipient
    /// @param _amount The amount of tokens to be transferred
    /// @return Whether the transfer was successful or not
    function transfer(address _to, uint256 _amount) returns (bool success) {
        if (!transfersEnabled) throw;
        return doTransfer(msg.sender, _to, _amount);
    }

    /// @notice Send `_amount` tokens to `_to` from `_from` on the condition it
    ///  is approved by `_from`
    /// @param _from The address holding the tokens being transferred
    /// @param _to The address of the recipient
    /// @param _amount The amount of tokens to be transferred
    /// @return True if the transfer was successful
    function transferFrom(address _from, address _to, uint256 _amount
    ) returns (bool success) {

        // The controller of this contract can move tokens around at will,
        //  this is important to recognize! Confirm that you trust the
        //  controller of this contract, which in most situations should be
        //  another open source smart contract or 0x0
        if (msg.sender != controller) {
            if (!transfersEnabled) throw;

            // The standard ERC 20 transferFrom functionality
            if (allowed[_from][msg.sender] < _amount) return false;
            allowed[_from][msg.sender] -= _amount;
        }
        return doTransfer(_from, _to, _amount);
    }

    /// @dev This is the actual transfer function in the token contract, it can
    ///  only be called by other functions in this contract.
    /// @param _from The address holding the tokens being transferred
    /// @param _to The address of the recipient
    /// @param _amount The amount of tokens to be transferred
    /// @return True if the transfer was successful
    function doTransfer(address _from, address _to, uint _amount
    ) internal returns(bool) {

           if (_amount == 0) {
               return true;
           }

           if (parentSnapShotBlock >= block.number) throw;

           // Do not allow transfer to 0x0 or the token contract itself
           if ((_to == 0) || (_to == address(this))) throw;

           // If the amount being transfered is more than the balance of the
           //  account the transfer returns false
           var previousBalanceFrom = balanceOfAt(_from, block.number);
           if (previousBalanceFrom < _amount) {
               return false;
           }

           // Alerts the token controller of the transfer
           if (isContract(controller)) {
               if (!TokenController(controller).onTransfer(_from, _to, _amount))
               throw;
           }

           // First update the balance array with the new value for the address
           //  sending the tokens
           updateValueAtNow(balances[_from], previousBalanceFrom - _amount);

           // Then update the balance array with the new value for the address
           //  receiving the tokens
           var previousBalanceTo = balanceOfAt(_to, block.number);
           if (previousBalanceTo + _amount < previousBalanceTo) throw; // Check for overflow
           updateValueAtNow(balances[_to], previousBalanceTo + _amount);

           // An event to make the transfer easy to find on the blockchain
           Transfer(_from, _to, _amount);

           return true;
    }

    /// @param _owner The address that's balance is being requested
    /// @return The balance of `_owner` at the current block
    function balanceOf(address _owner) constant returns (uint256 balance) {
        return balanceOfAt(_owner, block.number);
    }

    /// @notice `msg.sender` approves `_spender` to spend `_amount` tokens on
    ///  its behalf. This is a modified version of the ERC20 approve function
    ///  to be a little bit safer
    /// @param _spender The address of the account able to transfer the tokens
    /// @param _amount The amount of tokens to be approved for transfer
    /// @return True if the approval was successful
    function approve(address _spender, uint256 _amount) returns (bool success) {
        if (!transfersEnabled) throw;

        // To change the approve amount you first have to reduce the addresses`
        //  allowance to zero by calling `approve(_spender,0)` if it is not
        //  already 0 to mitigate the race condition described here:
        //  https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
        if ((_amount!=0) && (allowed[msg.sender][_spender] !=0)) throw;

        // Alerts the token controller of the approve function call
        if (isContract(controller)) {
            if (!TokenController(controller).onApprove(msg.sender, _spender, _amount))
                throw;
        }

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

    /// @dev This function makes it easy to read the `allowed[]` map
    /// @param _owner The address of the account that owns the token
    /// @param _spender The address of the account able to transfer the tokens
    /// @return Amount of remaining tokens of _owner that _spender is allowed
    ///  to spend
    function allowance(address _owner, address _spender
    ) constant returns (uint256 remaining) {
        return allowed[_owner][_spender];
    }

    /// @notice `msg.sender` approves `_spender` to send `_amount` tokens on
    ///  its behalf, and then a function is triggered in the contract that is
    ///  being approved, `_spender`. This allows users to use their tokens to
    ///  interact with contracts in one function call instead of two
    /// @param _spender The address of the contract able to transfer the tokens
    /// @param _amount The amount of tokens to be approved for transfer
    /// @return True if the function call was successful
    function approveAndCall(address _spender, uint256 _amount, bytes _extraData
    ) returns (bool success) {
        if (!approve(_spender, _amount)) throw;

        ApproveAndCallFallBack(_spender).receiveApproval(
            msg.sender,
            _amount,
            this,
            _extraData
        );

        return true;
    }

    /// @dev This function makes it easy to get the total number of tokens
    /// @return The total number of tokens
    function totalSupply() constant returns (uint) {
        return totalSupplyAt(block.number);
    }


////////////////
// Query balance and totalSupply in History
////////////////

    /// @dev Queries the balance of `_owner` at a specific `_blockNumber`
    /// @param _owner The address from which the balance will be retrieved
    /// @param _blockNumber The block number when the balance is queried
    /// @return The balance at `_blockNumber`
    function balanceOfAt(address _owner, uint _blockNumber) constant
        returns (uint) {

        // These next few lines are used when the balance of the token is
        //  requested before a check point was ever created for this token, it
        //  requires that the `parentToken.balanceOfAt` be queried at the
        //  genesis block for that token as this contains initial balance of
        //  this token
        if ((balances[_owner].length == 0)
            || (balances[_owner][0].fromBlock > _blockNumber)) {
            if (address(parentToken) != 0) {
                return parentToken.balanceOfAt(_owner, min(_blockNumber, parentSnapShotBlock));
            } else {
                // Has no parent
                return 0;
            }

        // This will return the expected balance during normal situations
        } else {
            return getValueAt(balances[_owner], _blockNumber);
        }
    }

    /// @notice Total amount of tokens at a specific `_blockNumber`.
    /// @param _blockNumber The block number when the totalSupply is queried
    /// @return The total amount of tokens at `_blockNumber`
    function totalSupplyAt(uint _blockNumber) constant returns(uint) {

        // These next few lines are used when the totalSupply of the token is
        //  requested before a check point was ever created for this token, it
        //  requires that the `parentToken.totalSupplyAt` be queried at the
        //  genesis block for this token as that contains totalSupply of this
        //  token at this block number.
        if ((totalSupplyHistory.length == 0)
            || (totalSupplyHistory[0].fromBlock > _blockNumber)) {
            if (address(parentToken) != 0) {
                return parentToken.totalSupplyAt(min(_blockNumber, parentSnapShotBlock));
            } else {
                return 0;
            }

        // This will return the expected totalSupply during normal situations
        } else {
            return getValueAt(totalSupplyHistory, _blockNumber);
        }
    }

////////////////
// Clone Token Method
////////////////

    /// @notice Creates a new clone token with the initial distribution being
    ///  this token at `_snapshotBlock`
    /// @param _cloneTokenName Name of the clone token
    /// @param _cloneDecimalUnits Number of decimals of the smallest unit
    /// @param _cloneTokenSymbol Symbol of the clone token
    /// @param _snapshotBlock Block when the distribution of the parent token is
    ///  copied to set the initial distribution of the new clone token;
    ///  if the block is zero than the actual block, the current block is used
    /// @param _transfersEnabled True if transfers are allowed in the clone
    /// @return The address of the new MiniMeToken Contract
    function createCloneToken(
        string _cloneTokenName,
        uint8 _cloneDecimalUnits,
        string _cloneTokenSymbol,
        uint _snapshotBlock,
        bool _transfersEnabled
        ) returns(address) {
        if (_snapshotBlock == 0) _snapshotBlock = block.number;
        MiniMeToken cloneToken = tokenFactory.createCloneToken(
            this,
            _snapshotBlock,
            _cloneTokenName,
            _cloneDecimalUnits,
            _cloneTokenSymbol,
            _transfersEnabled
            );

        cloneToken.changeController(msg.sender);

        // An event to make the token easy to find on the blockchain
        NewCloneToken(address(cloneToken), _snapshotBlock);
        return address(cloneToken);
    }

////////////////
// Generate and destroy tokens
////////////////

    /// @notice Generates `_amount` tokens that are assigned to `_owner`
    /// @param _owner The address that will be assigned the new tokens
    /// @param _amount The quantity of tokens generated
    /// @return True if the tokens are generated correctly
    function generateTokens(address _owner, uint _amount
    ) onlyController returns (bool) {
        uint curTotalSupply = getValueAt(totalSupplyHistory, block.number);
        if (curTotalSupply + _amount < curTotalSupply) throw; // Check for overflow
        updateValueAtNow(totalSupplyHistory, curTotalSupply + _amount);
        var previousBalanceTo = balanceOf(_owner);
        if (previousBalanceTo + _amount < previousBalanceTo) throw; // Check for overflow
        updateValueAtNow(balances[_owner], previousBalanceTo + _amount);
        Transfer(0, _owner, _amount);
        return true;
    }


    /// @notice Burns `_amount` tokens from `_owner`
    /// @param _owner The address that will lose the tokens
    /// @param _amount The quantity of tokens to burn
    /// @return True if the tokens are burned correctly
    function destroyTokens(address _owner, uint _amount
    ) onlyController returns (bool) {
        uint curTotalSupply = getValueAt(totalSupplyHistory, block.number);
        if (curTotalSupply < _amount) throw;
        updateValueAtNow(totalSupplyHistory, curTotalSupply - _amount);
        var previousBalanceFrom = balanceOf(_owner);
        if (previousBalanceFrom < _amount) throw;
        updateValueAtNow(balances[_owner], previousBalanceFrom - _amount);
        Transfer(_owner, 0, _amount);
        return true;
    }

////////////////
// Enable tokens transfers
////////////////


    /// @notice Enables token holders to transfer their tokens freely if true
    /// @param _transfersEnabled True if transfers are allowed in the clone
    function enableTransfers(bool _transfersEnabled) onlyController {
        transfersEnabled = _transfersEnabled;
    }

////////////////
// Internal helper functions to query and set a value in a snapshot array
////////////////

    /// @dev `getValueAt` retrieves the number of tokens at a given block number
    /// @param checkpoints The history of values being queried
    /// @param _block The block number to retrieve the value at
    /// @return The number of tokens being queried
    function getValueAt(Checkpoint[] storage checkpoints, uint _block
    ) constant internal returns (uint) {
        if (checkpoints.length == 0) return 0;

        // Shortcut for the actual value
        if (_block >= checkpoints[checkpoints.length-1].fromBlock)
            return checkpoints[checkpoints.length-1].value;
        if (_block < checkpoints[0].fromBlock) return 0;

        // Binary search of the value in the array
        uint min = 0;
        uint max = checkpoints.length-1;
        while (max > min) {
            uint mid = (max + min + 1)/ 2;
            if (checkpoints[mid].fromBlock<=_block) {
                min = mid;
            } else {
                max = mid-1;
            }
        }
        return checkpoints[min].value;
    }

    /// @dev `updateValueAtNow` used to update the `balances` map and the
    ///  `totalSupplyHistory`
    /// @param checkpoints The history of data being updated
    /// @param _value The new number of tokens
    function updateValueAtNow(Checkpoint[] storage checkpoints, uint _value
    ) internal  {
        if ((checkpoints.length == 0)
        || (checkpoints[checkpoints.length -1].fromBlock < block.number)) {
               Checkpoint newCheckPoint = checkpoints[ checkpoints.length++ ];
               newCheckPoint.fromBlock =  uint128(block.number);
               newCheckPoint.value = uint128(_value);
           } else {
               Checkpoint oldCheckPoint = checkpoints[checkpoints.length-1];
               oldCheckPoint.value = uint128(_value);
           }
    }

    /// @dev Internal function to determine if an address is a contract
    /// @param _addr The address being queried
    /// @return True if `_addr` is a contract
    function isContract(address _addr) constant internal returns(bool) {
        uint size;
        if (_addr == 0) return false;
        assembly {
            size := extcodesize(_addr)
        }
        return size>0;
    }

    /// @dev Helper function to return a min betwen the two uints
    function min(uint a, uint b) internal returns (uint) {
        return a < b ? a : b;
    }

    /// @notice The fallback function: If the contract's controller has not been
    ///  set to 0, then the `proxyPayment` method is called which relays the
    ///  ether and creates tokens as described in the token controller contract
    function ()  payable {
        if (isContract(controller)) {
            if (! TokenController(controller).proxyPayment.value(msg.value)(msg.sender))
                throw;
        } else {
            throw;
        }
    }

//////////
// Safety Methods
//////////

    /// @notice This method can be used by the controller to extract mistakenly
    ///  sent tokens to this contract.
    /// @param _token The address of the token contract that you want to recover
    ///  set to 0 in case you want to extract ether.
    function claimTokens(address _token) public onlyController {
      if (_token == 0x0) {
        controller.transfer(this.balance);
        return;
      }

      ERC20 token = ERC20(_token);
      uint256 balance = token.balanceOf(this);
      token.transfer(controller, balance);
      ClaimedTokens(_token, controller, balance);
    }

////////////////
// Events
////////////////
    event ClaimedTokens(address indexed _token, address indexed _controller, uint256 _amount);
    event Transfer(address indexed _from, address indexed _to, uint256 _amount);
    event NewCloneToken(address indexed _cloneToken, uint _snapshotBlock);
    event Approval(
        address indexed _owner,
        address indexed _spender,
        uint256 _amount
        );

}


////////////////
// MiniMeTokenFactory
////////////////

/// @dev This contract is used to generate clone contracts from a contract.
///  In solidity this is the way to create a contract from a contract of the
///  same class
contract MiniMeTokenFactory {

    /// @notice Update the DApp by creating a new token with new functionalities
    ///  the msg.sender becomes the controller of this clone token
    /// @param _parentToken Address of the token being cloned
    /// @param _snapshotBlock Block of the parent token that will
    ///  determine the initial distribution of the clone token
    /// @param _tokenName Name of the new token
    /// @param _decimalUnits Number of decimals of the new token
    /// @param _tokenSymbol Token Symbol for the new token
    /// @param _transfersEnabled If true, tokens will be able to be transferred
    /// @return The address of the new token contract
    function createCloneToken(
        address _parentToken,
        uint _snapshotBlock,
        string _tokenName,
        uint8 _decimalUnits,
        string _tokenSymbol,
        bool _transfersEnabled
    ) returns (MiniMeToken) {
        MiniMeToken newToken = new MiniMeToken(
            this,
            _parentToken,
            _snapshotBlock,
            _tokenName,
            _decimalUnits,
            _tokenSymbol,
            _transfersEnabled
            );

        newToken.changeController(msg.sender);
        return newToken;
    }
}

/**
 * @title SafeMath
 * @dev Math operations with safety checks that throw on error
 */
library SafeMath {
  function mul(uint256 a, uint256 b) internal returns (uint256) {
    uint256 c = a * b;
    assert(a == 0 || c / a == b);
    return c;
  }

  function div(uint256 a, uint256 b) internal 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 returns (uint256) {
    assert(b <= a);
    return a - b;
  }

  function add(uint256 a, uint256 b) internal returns (uint256) {
    uint256 c = a + b;
    assert(c >= a);
    return c;
  }
}

contract PreSale is Controlled, TokenController {
  using SafeMath for uint256;

  uint256 constant public exchangeRate = 1; // ETH-APT exchange rate
  uint256 constant public investor_bonus = 25;

  MiniMeToken public apt;
  address public place_holder;
  address public preSaleWallet;

  uint256 public totalSupplyCap;            // Total APT supply to be generated
  uint256 public totalSold;                 // How much tokens have been sold

  uint256 public minimum_investment;

  uint256 public startBlock;
  uint256 public endBlock;

  uint256 public initializedBlock;
  uint256 public finalizedBlock;

  bool public paused;

  modifier initialized() {
    assert(initializedBlock != 0);
    _;
  }

  modifier contributionOpen() {
    assert(getBlockNumber() >= startBlock &&
           getBlockNumber() <= endBlock &&
           finalizedBlock == 0);
    _;
  }

  modifier notPaused() {
    require(!paused);
    _;
  }

  function PreSale(address _apt, address _place_holder) {
    require(_apt != 0x0);
    require(_place_holder != 0x0);
    apt = MiniMeToken(_apt);
    place_holder = _place_holder;
  }

  function initialize(
      address _preSaleWallet,
      uint256 _totalSupplyCap,
      uint256 _minimum_investment,
      uint256 _startBlock,
      uint256 _endBlock
  ) public onlyController {
    // Initialize only once
    require(initializedBlock == 0);

    assert(apt.totalSupply() == 0);
    assert(apt.controller() == address(this));
    assert(apt.decimals() == 18);  // Same amount of decimals as ETH

    require(_preSaleWallet != 0x0);
    preSaleWallet = _preSaleWallet;

    assert(_startBlock >= getBlockNumber());
    require(_startBlock < _endBlock);
    startBlock = _startBlock;
    endBlock = _endBlock;

    require(_totalSupplyCap > 0);
    totalSupplyCap = _totalSupplyCap;

    minimum_investment = _minimum_investment;

    initializedBlock = getBlockNumber();
    Initialized(initializedBlock);
  }

  /// @notice If anybody sends Ether directly to this contract, consider he is
  /// getting APTs.
  function () public payable notPaused {
    proxyPayment(msg.sender);
  }

  //////////
  // TokenController functions
  //////////

  /// @notice This method will generally be called by the APT token contract to
  ///  acquire APTs. Or directly from third parties that want to acquire APTs in
  ///  behalf of a token holder.
  /// @param _th APT holder where the APTs will be minted.
  function proxyPayment(address _th) public payable notPaused initialized contributionOpen returns (bool) {
    require(_th != 0x0);
    doBuy(_th);
    return true;
  }

  function onTransfer(address, address, uint256) public returns (bool) {
    return false;
  }

  function onApprove(address, address, uint256) public returns (bool) {
    return false;
  }

  function doBuy(address _th) internal {
    require(msg.value >= minimum_investment);

    // Antispam mechanism
    address caller;
    if (msg.sender == address(apt)) {
      caller = _th;
    } else {
      caller = msg.sender;
    }
    assert(!isContract(caller));

    uint256 toFund = msg.value;
    uint256 leftForSale = tokensForSale();
    if (toFund > 0) {
      if (leftForSale > 0) {
        uint256 tokensGenerated = toFund.mul(exchangeRate);

        // Check total supply cap reached, sell the all remaining tokens
        if (tokensGenerated > leftForSale) {
          tokensGenerated = leftForSale;
          toFund = leftForSale.div(exchangeRate);
        }

        assert(apt.generateTokens(_th, tokensGenerated));
        totalSold = totalSold.add(tokensGenerated);

        preSaleWallet.transfer(toFund);
        NewSale(_th, toFund, tokensGenerated);
      } else {
        toFund = 0;
      }
    }

    uint256 toReturn = msg.value.sub(toFund);
    if (toReturn > 0) {
      caller.transfer(toReturn);
    }
  }

  /// @dev Internal function to determine if an address is a contract
  /// @param _addr The address being queried
  /// @return True if `_addr` is a contract
  function isContract(address _addr) constant internal returns (bool) {
    if (_addr == 0) return false;
    uint256 size;
    assembly {
      size := extcodesize(_addr)
    }
    return (size > 0);
  }

  /// @notice This method will can be called by the controller before the contribution period
  ///  end or by anybody after the `endBlock`. This method finalizes the contribution period
  ///  by creating the remaining tokens and transferring the controller to the configured
  ///  controller.
  function finalize() public initialized {
    require(finalizedBlock == 0);
    assert(getBlockNumber() >= startBlock);
    assert(msg.sender == controller || getBlockNumber() > endBlock || tokensForSale() == 0);

    apt.changeController(place_holder);

    finalizedBlock = getBlockNumber();

    Finalized(finalizedBlock);
  }

  //////////
  // Constant functions
  //////////

  /// @return Total tokens availale for the sale in weis.
  function tokensForSale() public constant returns(uint256) {
    return totalSupplyCap > totalSold ? totalSupplyCap - totalSold : 0;
  }

  //////////
  // Testing specific methods
  //////////

  /// @notice This function is overridden by the test Mocks.
  function getBlockNumber() internal constant returns (uint256) {
    return block.number;
  }


  //////////
  // Safety Methods
  //////////

  /// @notice This method can be used by the controller to extract mistakenly
  ///  sent tokens to this contract.
  /// @param _token The address of the token contract that you want to recover
  ///  set to 0 in case you want to extract ether.
  function claimTokens(address _token) public onlyController {
    if (apt.controller() == address(this)) {
      apt.claimTokens(_token);
    }

    if (_token == 0x0) {
      controller.transfer(this.balance);
      return;
    }

    ERC20 token = ERC20(_token);
    uint256 balance = token.balanceOf(this);
    token.transfer(controller, balance);
    ClaimedTokens(_token, controller, balance);
  }

  /// @notice Pauses the contribution if there is any issue
  function pauseContribution(bool _paused) onlyController {
    paused = _paused;
  }

  event ClaimedTokens(address indexed _token, address indexed _controller, uint256 _amount);
  event NewSale(address indexed _th, uint256 _amount, uint256 _tokens);
  event Initialized(uint _now);
  event Finalized(uint _now);
}

Contract Security Audit

Contract ABI

[{"constant":true,"inputs":[],"name":"endBlock","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"tokensForSale","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"preSaleWallet","outputs":[{"name":"","type":"address"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"_paused","type":"bool"}],"name":"pauseContribution","outputs":[],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"exchangeRate","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"_newController","type":"address"}],"name":"changeController","outputs":[],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"finalizedBlock","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"startBlock","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"","type":"address"},{"name":"","type":"address"},{"name":"","type":"uint256"}],"name":"onTransfer","outputs":[{"name":"","type":"bool"}],"payable":false,"type":"function"},{"constant":false,"inputs":[],"name":"finalize","outputs":[],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"paused","outputs":[{"name":"","type":"bool"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"totalSold","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"apt","outputs":[{"name":"","type":"address"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"minimum_investment","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"initializedBlock","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"totalSupplyCap","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"investor_bonus","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"","type":"address"},{"name":"","type":"address"},{"name":"","type":"uint256"}],"name":"onApprove","outputs":[{"name":"","type":"bool"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"_token","type":"address"}],"name":"claimTokens","outputs":[],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"place_holder","outputs":[{"name":"","type":"address"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"_th","type":"address"}],"name":"proxyPayment","outputs":[{"name":"","type":"bool"}],"payable":true,"type":"function"},{"constant":true,"inputs":[],"name":"controller","outputs":[{"name":"","type":"address"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"_preSaleWallet","type":"address"},{"name":"_totalSupplyCap","type":"uint256"},{"name":"_minimum_investment","type":"uint256"},{"name":"_startBlock","type":"uint256"},{"name":"_endBlock","type":"uint256"}],"name":"initialize","outputs":[],"payable":false,"type":"function"},{"inputs":[{"name":"_apt","type":"address"},{"name":"_place_holder","type":"address"}],"payable":false,"type":"constructor"},{"payable":true,"type":"fallback"},{"anonymous":false,"inputs":[{"indexed":true,"name":"_token","type":"address"},{"indexed":true,"name":"_controller","type":"address"},{"indexed":false,"name":"_amount","type":"uint256"}],"name":"ClaimedTokens","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"_th","type":"address"},{"indexed":false,"name":"_amount","type":"uint256"},{"indexed":false,"name":"_tokens","type":"uint256"}],"name":"NewSale","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"_now","type":"uint256"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"_now","type":"uint256"}],"name":"Finalized","type":"event"}]

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

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

00000000000000000000000023ae3c5b39b12f0693e05435eeaa1e51d8c615300000000000000000000000008ca22cb28f565cdb12f95b227d06a937f80eb07f

-----Decoded View---------------
Arg [0] : _apt (address): 0x23aE3C5B39B12f0693e05435EeaA1e51d8c61530
Arg [1] : _place_holder (address): 0x8ca22CB28f565cDB12F95B227d06a937f80eB07f

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 00000000000000000000000023ae3c5b39b12f0693e05435eeaa1e51d8c61530
Arg [1] : 0000000000000000000000008ca22cb28f565cdb12f95b227d06a937f80eb07f


Swarm Source

bzzr://b8e45e15174fcbe17bb458cfea5663f0b6a472336b1255bd026b8f7304dd72e8
Block Transaction Difficulty Gas Used Reward
Block Uncle Number Difficulty Gas Used Reward
Loading
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.

A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.