Sponsored Link:  Up to 2% Cryptocurrency Cashback - Reserve your card - Monaco App - www.mona.co
Contract Overview
ETH Balance: 0 Ether
ETH USD Value: $0
No Of Transactions: 79 txns
  Latest 25 txns from a total Of 79 transactions View All

TxHash Age From To Value [TxFee]
0x07daeb396d6f37163a48d5843c46f68d8154b60cfd734d45cc1b7a42244bfd2c114 days 18 hrs ago0x9779b88b432ef040181a71cad464eb65b307aaa1  IN   0x3b2150afd63266f46fbebbea4964d3b8c69b27eb0 Ether0.004
0x1e6901a9034a5287898e0fcb6dea5b949dee6904a92c16cc767997c49ac9de58115 days 6 hrs ago0x36ba245f96ff9e5ed402a8642deb169f72fe04c4  IN   0x3b2150afd63266f46fbebbea4964d3b8c69b27eb0 Ether0.001974609
0xf0f9998d560c37037d06299e2d8646a11d359b9a215c143bc8497397e91f8ade125 days 3 hrs ago0xb610aa04af410b6622084ad713c5b2d60ebc356e  IN   0x3b2150afd63266f46fbebbea4964d3b8c69b27eb0 Ether0.001974609
0x749637d95cd802d7e34bc6f56f6554551059bb25815ce41910b6535c60904199126 days 19 hrs ago0x4d7dafabbf0d3deb09fac4b624f1fea01412bfac  IN   0x3b2150afd63266f46fbebbea4964d3b8c69b27eb0 Ether0.0042
0x54a4af18b14923d3508181e9eb355e671f6fee491ed2faebaf876c69888fe6e5133 days 41 mins ago0x44a99f7bf3ff4f4106ff692165d7cd43db3aad79  IN   0x3b2150afd63266f46fbebbea4964d3b8c69b27eb0 Ether0.001974609
0x9641025f8912d944144207b35a508d9ec9df15ff8b481df0f921fbbec21a12e3138 days 12 hrs ago0x2af9ee92cf404c68b3523b1959a57535ba0d780d  IN   0x3b2150afd63266f46fbebbea4964d3b8c69b27eb0 Ether0.004419363
0x945f5ad506f4a4cbed633b4c281ae10dc85071583e114c04c9c69e3315131528138 days 13 hrs ago0x3833f8dbdbd6bdcb6a883ff209b869148965b364  IN   0x3b2150afd63266f46fbebbea4964d3b8c69b27eb0 Ether0.001974609
0xfdb951052a20130f4395193ab6d0deb4cd8c5583684bd6a4d0a276b0dfd923b5138 days 13 hrs ago0x3833f8dbdbd6bdcb6a883ff209b869148965b364  IN   0x3b2150afd63266f46fbebbea4964d3b8c69b27eb0 Ether0.0042
0xcef32a308e62b095688ce988a8a0f783c41791b07f6eccc0e0344444c40288af138 days 23 hrs ago0x23afdacb2d3a5257d726808b507dc5599617ac55  IN   0x3b2150afd63266f46fbebbea4964d3b8c69b27eb0 Ether0.00564174
0xffcb0f1a6bdb9a68f47f2657d0a6f5d3bb28d59d53c48694612bb530321528c0139 days 4 hrs ago0x770810554dc0a80df4294c82d7b037646c8c3945  IN   0x3b2150afd63266f46fbebbea4964d3b8c69b27eb0 Ether0.000094029
0xe056793deda369ff3de64c71c3665f61d2475190d2be47b4d45b97421f083c15142 days 6 hrs ago0x1c98527c52a53f86bcf3048ebe4ed83f09a835d4  IN   0x3b2150afd63266f46fbebbea4964d3b8c69b27eb0 Ether0.001974609
0xdc038fa3606525ab4575f536c8af4686915fc3eb861ec3461bcf51c941f1f73f151 days 18 hrs ago0x820910798bdb9b7885bfb7cf9bb37c70fd67e21a  IN   0x3b2150afd63266f46fbebbea4964d3b8c69b27eb0 Ether0.00376116
0x6d00855bf1bd102ceff54e00781040d2b5d19685a7ca8b34387e12ccd0492589151 days 21 hrs ago0x4d7dafabbf0d3deb09fac4b624f1fea01412bfac  IN   0x3b2150afd63266f46fbebbea4964d3b8c69b27eb0 Ether0.001659609
0x4fb5d130af23c4bb51240e996ec62e8f76b1b65cf45e5a93c9c27093831e51fb152 days 17 hrs ago0xba17550690656f95b93bde705db0f23d5de98015  IN   0x3b2150afd63266f46fbebbea4964d3b8c69b27eb0 Ether0.00470145
0x5b88ef4d1799e0e1af3a27b03c5ff1d93df576eb0eafd12491ed6fae061bbc18152 days 18 hrs ago0x8ea91406e59a1be333bb4a660fb9d4250a2ea66a  IN   0x3b2150afd63266f46fbebbea4964d3b8c69b27eb0 Ether0.00470145
0xcc3f2ad827c75c50ce9ea633a0f95d2c79ffcd94d6c0344f826313bbbae3b57f152 days 21 hrs ago0xf5d64d673cf306d47de04cebffee7bcc8962cd75  IN   0x3b2150afd63266f46fbebbea4964d3b8c69b27eb0 Ether0.001974609
0xc58623baa9282f0da250cbf56f82fbdbe228fb44024c7af0eb0ce62789fba2ec152 days 22 hrs ago0x3521e8b771ff4a4eb234bddaefc5bc460fd78de9  IN   0x3b2150afd63266f46fbebbea4964d3b8c69b27eb0 Ether0.001974609
0xabb4fe5f9cb9532e02878461ae71d51e43880f654adc40d07ef4efb27265572f152 days 23 hrs ago0xaa8b781576c2275c3db5a1e16d239b6a060173d6  IN   0x3b2150afd63266f46fbebbea4964d3b8c69b27eb0 Ether0.001974609
0x056b20b0deaa06ccbb59bd40eaa8752eaa2d2272ee45b3ff665657e04ed36496153 days 1 hr ago0xae78fcacd22638344cd69c5b9805a86356444ad6  IN   0x3b2150afd63266f46fbebbea4964d3b8c69b27eb0 Ether0.00564174
0x4ee969690a83762f432579dba88df958d5e96a87a8d04b5e70d9a92ab412c101153 days 2 hrs ago0xda92889ebfc286dbf7afab5a28c1f7bd2164a130  IN   0x3b2150afd63266f46fbebbea4964d3b8c69b27eb0 Ether0.001974609
0x9ce2788c82d5b7387af4d685c86b6d08fa05f4acb5b0aa2cec1c74d67e1bd7e5153 days 3 hrs ago0x696b80979ccbb12883625f91d69f431111f42c96  IN   0x3b2150afd63266f46fbebbea4964d3b8c69b27eb0 Ether0.0002
0xc17b4d757f8641f240f2467bb10fdfa69b076f3bd4d2dfdc5ce44e48bdacbe4d153 days 4 hrs ago0x2410a13a5458421bbfa1214497163af5063be356  IN   0x3b2150afd63266f46fbebbea4964d3b8c69b27eb0 Ether0.00470145
0x8fb9cb73464b2104964631c6cd41feadb805ede5a22f34b9ec2ae563ad8b2de3153 days 4 hrs ago0x6a6347b8c7797294a69d6e606b211a6d0ecc678d  IN   0x3b2150afd63266f46fbebbea4964d3b8c69b27eb0 Ether0.0042
0x7fdb6f0f90fe2e15c40dccd79280d229602e2ed1051dd4f8ed49591131f2e8ee153 days 4 hrs ago0x8b97dbf5ee4f3471b023cd08f1d222771a30843b  IN   0x3b2150afd63266f46fbebbea4964d3b8c69b27eb0 Ether0.002
0xdefa549c92da72717f37219661e067ef196fec25f2494235f2ec79adcf066631153 days 9 hrs ago0x00881f5f6ab534c7cd9f2ee965fb311142cd1040  IN   0x3b2150afd63266f46fbebbea4964d3b8c69b27eb0 Ether0.00158058
[ Download CSV Export  ] 
 Internal Transactions as a result of Contract Execution
  Latest 1 Internal Transaction

ParentTxHash Block Age From To Value
0x978885efcc5788aec3fd7941377eefc0f39b8a33509c48b4fc2c5b22601577623861176187 days 23 hrs ago0x3b2150afd63266f46fbebbea4964d3b8c69b27eb0x0fb81a518dca5495986c5c2ec29e989390e0e4061,371.6542 Ether
[ Download CSV Export  ] 
Contract Name: PreICOProxyBuyer
Compiler Version: v0.4.8+commit.60cc1668
Optimization Enabled: Yes
Runs (Optimiser):  200



  Contract Source Code   Find Similiar Contracts
/**
 * Math operations with safety checks
 */
contract SafeMath {
  function safeMul(uint a, uint b) internal returns (uint) {
    uint c = a * b;
    assert(a == 0 || c / a == b);
    return c;
  }

  function safeDiv(uint a, uint b) internal returns (uint) {
    assert(b > 0);
    uint c = a / b;
    assert(a == b * c + a % b);
    return c;
  }

  function safeSub(uint a, uint b) internal returns (uint) {
    assert(b <= a);
    return a - b;
  }

  function safeAdd(uint a, uint b) internal returns (uint) {
    uint c = a + b;
    assert(c>=a && c>=b);
    return c;
  }

  function max64(uint64 a, uint64 b) internal constant returns (uint64) {
    return a >= b ? a : b;
  }

  function min64(uint64 a, uint64 b) internal constant returns (uint64) {
    return a < b ? a : b;
  }

  function max256(uint256 a, uint256 b) internal constant returns (uint256) {
    return a >= b ? a : b;
  }

  function min256(uint256 a, uint256 b) internal constant returns (uint256) {
    return a < b ? a : b;
  }

  function assert(bool assertion) internal {
    if (!assertion) {
      throw;
    }
  }
}



/**
 * Safe unsigned safe math.
 *
 * https://blog.aragon.one/library-driven-development-in-solidity-2bebcaf88736#.750gwtwli
 *
 * Originally from https://raw.githubusercontent.com/AragonOne/zeppelin-solidity/master/contracts/SafeMathLib.sol
 *
 * Maintained here until merged to mainline zeppelin-solidity.
 *
 */
library SafeMathLib {

  function times(uint a, uint b) returns (uint) {
    uint c = a * b;
    assert(a == 0 || c / a == b);
    return c;
  }

  function minus(uint a, uint b) returns (uint) {
    assert(b <= a);
    return a - b;
  }

  function plus(uint a, uint b) returns (uint) {
    uint c = a + b;
    assert(c>=a);
    return c;
  }

  function assert(bool assertion) private {
    if (!assertion) throw;
  }
}




/*
 * Ownable
 *
 * Base contract with an owner.
 * Provides onlyOwner modifier, which prevents function from running if it is called by anyone other than the owner.
 */
contract Ownable {
  address public owner;

  function Ownable() {
    owner = msg.sender;
  }

  modifier onlyOwner() {
    if (msg.sender != owner) {
      throw;
    }
    _;
  }

  function transferOwnership(address newOwner) onlyOwner {
    if (newOwner != address(0)) {
      owner = newOwner;
    }
  }

}


/*
 * Haltable
 *
 * Abstract contract that allows children to implement an
 * emergency stop mechanism. Differs from Pausable by causing a throw when in halt mode.
 *
 *
 * Originally envisioned in FirstBlood ICO contract.
 */
contract Haltable is Ownable {
  bool public halted;

  modifier stopInEmergency {
    if (halted) throw;
    _;
  }

  modifier onlyInEmergency {
    if (!halted) throw;
    _;
  }

  // called by the owner on emergency, triggers stopped state
  function halt() external onlyOwner {
    halted = true;
  }

  // called by the owner on end of emergency, returns to normal state
  function unhalt() external onlyOwner onlyInEmergency {
    halted = false;
  }

}


/**
 * Interface for defining crowdsale pricing.
 */
contract PricingStrategy {

  /** Interface declaration. */
  function isPricingStrategy() public constant returns (bool) {
    return true;
  }

  /** Self check if all references are correctly set.
   *
   * Checks that pricing strategy matches crowdsale parameters.
   */
  function isSane(address crowdsale) public constant returns (bool) {
    return true;
  }

  /**
   * When somebody tries to buy tokens for X eth, calculate how many tokens they get.
   *
   *
   * @param value - What is the value of the transaction send in as wei
   * @param tokensSold - how much tokens have been sold this far
   * @param weiRaised - how much money has been raised this far
   * @param msgSender - who is the investor of this transaction
   * @param decimals - how many decimal units the token has
   * @return Amount of tokens the investor receives
   */
  function calculatePrice(uint value, uint weiRaised, uint tokensSold, address msgSender, uint decimals) public constant returns (uint tokenAmount);
}


/**
 * Finalize agent defines what happens at the end of succeseful crowdsale.
 *
 * - Allocate tokens for founders, bounties and community
 * - Make tokens transferable
 * - etc.
 */
contract FinalizeAgent {

  function isFinalizeAgent() public constant returns(bool) {
    return true;
  }

  /** Return true if we can run finalizeCrowdsale() properly.
   *
   * This is a safety check function that doesn't allow crowdsale to begin
   * unless the finalizer has been set up properly.
   */
  function isSane() public constant returns (bool);

  /** Called once by crowdsale finalize() if the sale was success. */
  function finalizeCrowdsale();

}




/*
 * ERC20 interface
 * see https://github.com/ethereum/EIPs/issues/20
 */
contract ERC20 {
  uint public totalSupply;
  function balanceOf(address who) constant returns (uint);
  function allowance(address owner, address spender) constant returns (uint);

  function transfer(address to, uint value) returns (bool ok);
  function transferFrom(address from, address to, uint value) returns (bool ok);
  function approve(address spender, uint value) returns (bool ok);
  event Transfer(address indexed from, address indexed to, uint value);
  event Approval(address indexed owner, address indexed spender, uint value);
}


/**
 * A token that defines fractional units as decimals.
 */
contract FractionalERC20 is ERC20 {

  uint public decimals;

}



/**
 * Abstract base contract for token sales.
 *
 * Handle
 * - start and end dates
 * - accepting investments
 * - minimum funding goal and refund
 * - various statistics during the crowdfund
 * - different pricing strategies
 * - different investment policies (require server side customer id, allow only whitelisted addresses)
 *
 */
contract Crowdsale is Haltable {

  using SafeMathLib for uint;

  /* The token we are selling */
  FractionalERC20 public token;

  /* How we are going to price our offering */
  PricingStrategy public pricingStrategy;

  /* Post-success callback */
  FinalizeAgent public finalizeAgent;

  /* tokens will be transfered from this address */
  address public multisigWallet;

  /* if the funding goal is not reached, investors may withdraw their funds */
  uint public minimumFundingGoal;

  /* the UNIX timestamp start date of the crowdsale */
  uint public startsAt;

  /* the UNIX timestamp end date of the crowdsale */
  uint public endsAt;

  /* the number of tokens already sold through this contract*/
  uint public tokensSold = 0;

  /* How many wei of funding we have raised */
  uint public weiRaised = 0;

  /* How many distinct addresses have invested */
  uint public investorCount = 0;

  /* How much wei we have returned back to the contract after a failed crowdfund. */
  uint public loadedRefund = 0;

  /* How much wei we have given back to investors.*/
  uint public weiRefunded = 0;

  /* Has this crowdsale been finalized */
  bool public finalized;

  /* Do we need to have unique contributor id for each customer */
  bool public requireCustomerId;

  /**
    * Do we verify that contributor has been cleared on the server side (accredited investors only).
    * This method was first used in FirstBlood crowdsale to ensure all contributors have accepted terms on sale (on the web).
    */
  bool public requiredSignedAddress;

  /* Server side address that signed allowed contributors (Ethereum addresses) that can participate the crowdsale */
  address public signerAddress;

  /** How much ETH each address has invested to this crowdsale */
  mapping (address => uint256) public investedAmountOf;

  /** How much tokens this crowdsale has credited for each investor address */
  mapping (address => uint256) public tokenAmountOf;

  /** Addresses that are allowed to invest even before ICO offical opens. For testing, for ICO partners, etc. */
  mapping (address => bool) public earlyParticipantWhitelist;

  /** This is for manul testing for the interaction from owner wallet. You can set it to any value and inspect this in blockchain explorer to see that crowdsale interaction works. */
  uint public ownerTestValue;

  /** State machine
   *
   * - Preparing: All contract initialization calls and variables have not been set yet
   * - Prefunding: We have not passed start time yet
   * - Funding: Active crowdsale
   * - Success: Minimum funding goal reached
   * - Failure: Minimum funding goal not reached before ending time
   * - Finalized: The finalized has been called and succesfully executed
   * - Refunding: Refunds are loaded on the contract for reclaim.
   */
  enum State{Unknown, Preparing, PreFunding, Funding, Success, Failure, Finalized, Refunding}

  // A new investment was made
  event Invested(address investor, uint weiAmount, uint tokenAmount, uint128 customerId);

  // Refund was processed for a contributor
  event Refund(address investor, uint weiAmount);

  // The rules were changed what kind of investments we accept
  event InvestmentPolicyChanged(bool requireCustomerId, bool requiredSignedAddress, address signerAddress);

  // Address early participation whitelist status changed
  event Whitelisted(address addr, bool status);

  // Crowdsale end time has been changed
  event EndsAtChanged(uint endsAt);

  function Crowdsale(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal) {

    owner = msg.sender;

    token = FractionalERC20(_token);

    setPricingStrategy(_pricingStrategy);

    multisigWallet = _multisigWallet;
    if(multisigWallet == 0) {
        throw;
    }

    if(_start == 0) {
        throw;
    }

    startsAt = _start;

    if(_end == 0) {
        throw;
    }

    endsAt = _end;

    // Don't mess the dates
    if(startsAt >= endsAt) {
        throw;
    }

    // Minimum funding goal can be zero
    minimumFundingGoal = _minimumFundingGoal;
  }

  /**
   * Don't expect to just send in money and get tokens.
   */
  function() payable {
    throw;
  }

  /**
   * Make an investment.
   *
   * Crowdsale must be running for one to invest.
   * We must have not pressed the emergency brake.
   *
   * @param receiver The Ethereum address who receives the tokens
   * @param customerId (optional) UUID v4 to track the successful payments on the server side
   *
   */
  function investInternal(address receiver, uint128 customerId) stopInEmergency private {

    // Determine if it's a good time to accept investment from this participant
    if(getState() == State.PreFunding) {
      // Are we whitelisted for early deposit
      if(!earlyParticipantWhitelist[receiver]) {
        throw;
      }
    } else if(getState() == State.Funding) {
      // Retail participants can only come in when the crowdsale is running
      // pass
    } else {
      // Unwanted state
      throw;
    }

    uint weiAmount = msg.value;
    uint tokenAmount = pricingStrategy.calculatePrice(weiAmount, weiRaised, tokensSold, msg.sender, token.decimals());

    if(tokenAmount == 0) {
      // Dust transaction
      throw;
    }

    if(investedAmountOf[receiver] == 0) {
       // A new investor
       investorCount++;
    }

    // Update investor
    investedAmountOf[receiver] = investedAmountOf[receiver].plus(weiAmount);
    tokenAmountOf[receiver] = tokenAmountOf[receiver].plus(tokenAmount);

    // Update totals
    weiRaised = weiRaised.plus(weiAmount);
    tokensSold = tokensSold.plus(tokenAmount);

    // Check that we did not bust the cap
    if(isBreakingCap(weiAmount, tokenAmount, weiRaised, tokensSold)) {
      throw;
    }

    assignTokens(receiver, tokenAmount);

    // Pocket the money
    if(!multisigWallet.send(weiAmount)) throw;

    // Tell us invest was success
    Invested(receiver, weiAmount, tokenAmount, customerId);
  }

  /**
   * Preallocate tokens for the early investors.
   *
   * Preallocated tokens have been sold before the actual crowdsale opens.
   * This function mints the tokens and moves the crowdsale needle.
   *
   * Investor count is not handled; it is assumed this goes for multiple investors
   * and the token distribution happens outside the smart contract flow.
   *
   * No money is exchanged, as the crowdsale team already have received the payment.
   *
   * @param fullTokens tokens as full tokens - decimal places added internally
   * @param weiPrice Price of a single full token in wei
   *
   */
  function preallocate(address receiver, uint fullTokens, uint weiPrice) public onlyOwner {

    uint tokenAmount = fullTokens * 10**token.decimals();
    uint weiAmount = weiPrice * fullTokens; // This can be also 0, we give out tokens for free

    weiRaised = weiRaised.plus(weiAmount);
    tokensSold = tokensSold.plus(tokenAmount);

    investedAmountOf[receiver] = investedAmountOf[receiver].plus(weiAmount);
    tokenAmountOf[receiver] = tokenAmountOf[receiver].plus(tokenAmount);

    assignTokens(receiver, tokenAmount);

    // Tell us invest was success
    Invested(receiver, weiAmount, tokenAmount, 0);
  }

  /**
   * Allow anonymous contributions to this crowdsale.
   */
  function investWithSignedAddress(address addr, uint128 customerId, uint8 v, bytes32 r, bytes32 s) public payable {
     bytes32 hash = sha256(addr);
     if (ecrecover(hash, v, r, s) != signerAddress) throw;
     if(customerId == 0) throw;  // UUIDv4 sanity check
     investInternal(addr, customerId);
  }

  /**
   * Track who is the customer making the payment so we can send thank you email.
   */
  function investWithCustomerId(address addr, uint128 customerId) public payable {
    if(requiredSignedAddress) throw; // Crowdsale allows only server-side signed participants
    if(customerId == 0) throw;  // UUIDv4 sanity check
    investInternal(addr, customerId);
  }

  /**
   * Allow anonymous contributions to this crowdsale.
   */
  function invest(address addr) public payable {
    if(requireCustomerId) throw; // Crowdsale needs to track partipants for thank you email
    if(requiredSignedAddress) throw; // Crowdsale allows only server-side signed participants
    investInternal(addr, 0);
  }

  /**
   * Invest to tokens, recognize the payer and clear his address.
   *
   */
  function buyWithSignedAddress(uint128 customerId, uint8 v, bytes32 r, bytes32 s) public payable {
    investWithSignedAddress(msg.sender, customerId, v, r, s);
  }

  /**
   * Invest to tokens, recognize the payer.
   *
   */
  function buyWithCustomerId(uint128 customerId) public payable {
    investWithCustomerId(msg.sender, customerId);
  }

  /**
   * The basic entry point to participate the crowdsale process.
   *
   * Pay for funding, get invested tokens back in the sender address.
   */
  function buy() public payable {
    invest(msg.sender);
  }

  /**
   * Finalize a succcesful crowdsale.
   *
   * The owner can triggre a call the contract that provides post-crowdsale actions, like releasing the tokens.
   */
  function finalize() public inState(State.Success) onlyOwner stopInEmergency {

    // Already finalized
    if(finalized) {
      throw;
    }

    // Finalizing is optional. We only call it if we are given a finalizing agent.
    if(address(finalizeAgent) != 0) {
      finalizeAgent.finalizeCrowdsale();
    }

    finalized = true;
  }

  /**
   * Allow to (re)set finalize agent.
   *
   * Design choice: no state restrictions on setting this, so that we can fix fat finger mistakes.
   */
  function setFinalizeAgent(FinalizeAgent addr) onlyOwner {
    finalizeAgent = addr;

    // Don't allow setting bad agent
    if(!finalizeAgent.isFinalizeAgent()) {
      throw;
    }
  }

  /**
   * Set policy do we need to have server-side customer ids for the investments.
   *
   */
  function setRequireCustomerId(bool value) onlyOwner {
    requireCustomerId = value;
    InvestmentPolicyChanged(requireCustomerId, requiredSignedAddress, signerAddress);
  }

  /**
   * Set policy if all investors must be cleared on the server side first.
   *
   * This is e.g. for the accredited investor clearing.
   *
   */
  function setRequireSignedAddress(bool value, address _signerAddress) onlyOwner {
    requiredSignedAddress = value;
    signerAddress = _signerAddress;
    InvestmentPolicyChanged(requireCustomerId, requiredSignedAddress, signerAddress);
  }

  /**
   * Allow addresses to do early participation.
   *
   * TODO: Fix spelling error in the name
   */
  function setEarlyParicipantWhitelist(address addr, bool status) onlyOwner {
    earlyParticipantWhitelist[addr] = status;
    Whitelisted(addr, status);
  }

  /**
   * Allow crowdsale owner to close early or extend the crowdsale.
   *
   * This is useful e.g. for a manual soft cap implementation:
   * - after X amount is reached determine manual closing
   *
   * This may put the crowdsale to an invalid state,
   * but we trust owners know what they are doing.
   *
   */
  function setEndsAt(uint time) onlyOwner {

    if(now > time) {
      throw; // Don't change past
    }

    endsAt = time;
    EndsAtChanged(endsAt);
  }

  /**
   * Allow to (re)set pricing strategy.
   *
   * Design choice: no state restrictions on the set, so that we can fix fat finger mistakes.
   */
  function setPricingStrategy(PricingStrategy _pricingStrategy) onlyOwner {
    pricingStrategy = _pricingStrategy;

    // Don't allow setting bad agent
    if(!pricingStrategy.isPricingStrategy()) {
      throw;
    }
  }

  /**
   * Allow load refunds back on the contract for the refunding.
   *
   * The team can transfer the funds back on the smart contract in the case the minimum goal was not reached..
   */
  function loadRefund() public payable inState(State.Failure) {
    if(msg.value == 0) throw;
    loadedRefund = loadedRefund.plus(msg.value);
  }

  /**
   * Investors can claim refund.
   */
  function refund() public inState(State.Refunding) {
    uint256 weiValue = investedAmountOf[msg.sender];
    if (weiValue == 0) throw;
    investedAmountOf[msg.sender] = 0;
    weiRefunded = weiRefunded.plus(weiValue);
    Refund(msg.sender, weiValue);
    if (!msg.sender.send(weiValue)) throw;
  }

  /**
   * @return true if the crowdsale has raised enough money to be a succes
   */
  function isMinimumGoalReached() public constant returns (bool reached) {
    return weiRaised >= minimumFundingGoal;
  }

  /**
   * Check if the contract relationship looks good.
   */
  function isFinalizerSane() public constant returns (bool sane) {
    return finalizeAgent.isSane();
  }

  /**
   * Check if the contract relationship looks good.
   */
  function isPricingSane() public constant returns (bool sane) {
    return pricingStrategy.isSane(address(this));
  }

  /**
   * Crowdfund state machine management.
   *
   * We make it a function and do not assign the result to a variable, so there is no chance of the variable being stale.
   */
  function getState() public constant returns (State) {
    if(finalized) return State.Finalized;
    else if (address(finalizeAgent) == 0) return State.Preparing;
    else if (!finalizeAgent.isSane()) return State.Preparing;
    else if (!pricingStrategy.isSane(address(this))) return State.Preparing;
    else if (block.timestamp < startsAt) return State.PreFunding;
    else if (block.timestamp <= endsAt && !isCrowdsaleFull()) return State.Funding;
    else if (isMinimumGoalReached()) return State.Success;
    else if (!isMinimumGoalReached() && weiRaised > 0 && loadedRefund >= weiRaised) return State.Refunding;
    else return State.Failure;
  }

  /** This is for manual testing of multisig wallet interaction */
  function setOwnerTestValue(uint val) onlyOwner {
    ownerTestValue = val;
  }

  /** Interface marker. */
  function isCrowdsale() public constant returns (bool) {
    return true;
  }

  //
  // Modifiers
  //

  /** Modified allowing execution only if the crowdsale is currently running.  */
  modifier inState(State state) {
    if(getState() != state) throw;
    _;
  }


  //
  // Abstract functions
  //

  /**
   * Check if the current invested breaks our cap rules.
   *
   *
   * The child contract must define their own cap setting rules.
   * We allow a lot of flexibility through different capping strategies (ETH, token count)
   * Called from invest().
   *
   * @param weiAmount The amount of wei the investor tries to invest in the current transaction
   * @param tokenAmount The amount of tokens we try to give to the investor in the current transaction
   * @param weiRaisedTotal What would be our total raised balance after this transaction
   * @param tokensSoldTotal What would be our total sold tokens count after this transaction
   *
   * @return true if taking this investment would break our cap rules
   */
  function isBreakingCap(uint weiAmount, uint tokenAmount, uint weiRaisedTotal, uint tokensSoldTotal) constant returns (bool limitBroken);

  /**
   * Check if the current crowdsale is full and we can no longer sell any tokens.
   */
  function isCrowdsaleFull() public constant returns (bool);

  /**
   * Create new tokens or transfer issued tokens to the investor depending on the cap model.
   */
  function assignTokens(address receiver, uint tokenAmount) private;
}







/**
 * Standard ERC20 token with Short Hand Attack and approve() race condition mitigation.
 *
 * Based on code by FirstBlood:
 * https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
 */
contract StandardToken is ERC20, SafeMath {

  /* Token supply got increased and a new owner received these tokens */
  event Minted(address receiver, uint amount);

  /* Actual balances of token holders */
  mapping(address => uint) balances;

  /* approve() allowances */
  mapping (address => mapping (address => uint)) allowed;

  /**
   *
   * Fix for the ERC20 short address attack
   *
   * http://vessenes.com/the-erc20-short-address-attack-explained/
   */
  modifier onlyPayloadSize(uint size) {
     if(msg.data.length != size + 4) {
       throw;
     }
     _;
  }

  function transfer(address _to, uint _value) onlyPayloadSize(2 * 32) returns (bool success) {
    balances[msg.sender] = safeSub(balances[msg.sender], _value);
    balances[_to] = safeAdd(balances[_to], _value);
    Transfer(msg.sender, _to, _value);
    return true;
  }

  function transferFrom(address _from, address _to, uint _value) returns (bool success) {
    uint _allowance = allowed[_from][msg.sender];

    // Check is not needed because safeSub(_allowance, _value) will already throw if this condition is not met
    // if (_value > _allowance) throw;

    balances[_to] = safeAdd(balances[_to], _value);
    balances[_from] = safeSub(balances[_from], _value);
    allowed[_from][msg.sender] = safeSub(_allowance, _value);
    Transfer(_from, _to, _value);
    return true;
  }

  function balanceOf(address _owner) constant returns (uint balance) {
    return balances[_owner];
  }

  function approve(address _spender, uint _value) returns (bool success) {

    // 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 ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw;

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

  function allowance(address _owner, address _spender) constant returns (uint remaining) {
    return allowed[_owner][_spender];
  }

  /**
   * Atomic increment of approved spending
   *
   * Works around https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
   *
   */
  function addApproval(address _spender, uint _addedValue)
  onlyPayloadSize(2 * 32)
  returns (bool success) {
      uint oldValue = allowed[msg.sender][_spender];
      allowed[msg.sender][_spender] = safeAdd(oldValue, _addedValue);
      Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
      return true;
  }

  /**
   * Atomic decrement of approved spending.
   *
   * Works around https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
   */
  function subApproval(address _spender, uint _subtractedValue)
  onlyPayloadSize(2 * 32)
  returns (bool success) {

      uint oldVal = allowed[msg.sender][_spender];

      if (_subtractedValue > oldVal) {
          allowed[msg.sender][_spender] = 0;
      } else {
          allowed[msg.sender][_spender] = safeSub(oldVal, _subtractedValue);
      }
      Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
      return true;
  }

}



/**
 * Collect funds from presale investors, buy tokens for them in a single transaction and distribute out tokens.
 *
 * - Collect funds from pre-sale investors
 * - Send funds to the crowdsale when it opens
 * - Allow owner to set the crowdsale
 * - Have refund after X days as a safety hatch if the crowdsale doesn't materilize
 * - Allow unlimited investors
 * - Tokens are distributed on PreICOProxyBuyer smart contract first
 * - The original investors can claim their tokens from the smart contract after the token transfer has been released
 * - All functions can be halted by owner if something goes wrong
 *
 */
contract PreICOProxyBuyer is Ownable, Haltable, SafeMath {

  /** How many investors we have now */
  uint public investorCount;

  /** How many wei we have raised totla. */
  uint public weiRaisedTotal;

  /** Who are our investors (iterable) */
  address[] public investors;

  /** How much they have invested */
  mapping(address => uint) public balances;

  /** How many tokens investors have claimed */
  mapping(address => uint) public claimed;

  /** When our refund freeze is over (UNIT timestamp) */
  uint public freezeEndsAt;

  /** What is the minimum buy in */
  uint public weiMinimumLimit;

  /** How many weis total we are allowed to collect. */
  uint public weiCap;

  /** How many tokens were bought */
  uint public tokensBought;

   /** How many investors have claimed their tokens */
  uint public claimCount;

  uint public totalClaimed;

  /** Our ICO contract where we will move the funds */
  Crowdsale public crowdsale;

  /** What is our current state. */
  enum State{Unknown, Funding, Distributing, Refunding}

  /** Somebody loaded their investment money */
  event Invested(address investor, uint value);

  /** Refund claimed */
  event Refunded(address investor, uint value);

  /** We executed our buy */
  event TokensBoughts(uint count);

  /** We distributed tokens to an investor */
  event Distributed(address investors, uint count);

  /**
   * Create presale contract where lock up period is given days
   */
  function PreICOProxyBuyer(address _owner, uint _freezeEndsAt, uint _weiMinimumLimit, uint _weiCap) {

    owner = _owner;

    // Give argument
    if(_freezeEndsAt == 0) {
      throw;
    }

    // Give argument
    if(_weiMinimumLimit == 0) {
      throw;
    }

    weiMinimumLimit = _weiMinimumLimit;
    weiCap = _weiCap;
    freezeEndsAt = _freezeEndsAt;
  }

  /**
   * Get the token we are distributing.
   */
  function getToken() public constant returns(FractionalERC20) {
    if(address(crowdsale) == 0)  {
      throw;
    }

    return crowdsale.token();
  }

  /**
   * Participate to a presale.
   */
  function invest() public stopInEmergency payable {

    // Cannot invest anymore through crowdsale when moving has begun
    if(getState() != State.Funding) throw;

    if(msg.value == 0) throw; // No empty buys

    address investor = msg.sender;

    bool existing = balances[investor] > 0;

    balances[investor] = safeAdd(balances[investor], msg.value);

    // Need to fulfill minimum limit
    if(balances[investor] < weiMinimumLimit) {
      throw;
    }

    // This is a new investor
    if(!existing) {
      investors.push(investor);
      investorCount++;
    }

    weiRaisedTotal = safeAdd(weiRaisedTotal, msg.value);
    if(weiRaisedTotal > weiCap) {
      throw;
    }

    Invested(investor, msg.value);
  }

  /**
   * Load funds to the crowdsale for all investors.
   *
   *
   */
  function buyForEverybody() stopInEmergency public {

    if(getState() != State.Funding) {
      // Only allow buy once
      throw;
    }

    // Crowdsale not yet set
    if(address(crowdsale) == 0) throw;

    // Buy tokens on the contract
    crowdsale.invest.value(weiRaisedTotal)(address(this));

    // Record how many tokens we got
    tokensBought = getToken().balanceOf(address(this));

    if(tokensBought == 0) {
      // Did not get any tokens
      throw;
    }

    TokensBoughts(tokensBought);
  }

  /**
   * How may tokens each investor gets.
   */
  function getClaimAmount(address investor) public constant returns (uint) {

    // Claims can be only made if we manage to buy tokens
    if(getState() != State.Distributing) {
      throw;
    }
    return safeMul(balances[investor], tokensBought) / weiRaisedTotal;
  }

  /**
   * How many tokens remain unclaimed for an investor.
   */
  function getClaimLeft(address investor) public constant returns (uint) {
    return safeSub(getClaimAmount(investor), claimed[investor]);
  }

  /**
   * Claim all remaining tokens for this investor.
   */
  function claimAll() {
    claim(getClaimLeft(msg.sender));
  }

  /**
   * Claim N bought tokens to the investor as the msg sender.
   *
   */
  function claim(uint amount) stopInEmergency {
    address investor = msg.sender;

    if(amount == 0) {
      throw;
    }

    if(getClaimLeft(investor) < amount) {
      // Woops we cannot get more than we have left
      throw;
    }

    // We track who many investor have (partially) claimed their tokens
    if(claimed[investor] == 0) {
      claimCount++;
    }

    claimed[investor] = safeAdd(claimed[investor], amount);
    totalClaimed = safeAdd(totalClaimed, amount);
    getToken().transfer(investor, amount);

    Distributed(investor, amount);
  }

  /**
   * ICO never happened. Allow refund.
   */
  function refund() stopInEmergency {

    // Trying to ask refund too soon
    if(getState() != State.Refunding) throw;

    address investor = msg.sender;
    if(balances[investor] == 0) throw;
    uint amount = balances[investor];
    delete balances[investor];
    if(!investor.send(amount)) throw;
    Refunded(investor, amount);
  }

  /**
   * Set the target crowdsale where we will move presale funds when the crowdsale opens.
   */
  function setCrowdsale(Crowdsale _crowdsale) public onlyOwner {
    crowdsale = _crowdsale;

    // Check interface
    if(!crowdsale.isCrowdsale()) true;
  }

  /**
   * Resolve the contract umambigious state.
   */
  function getState() public returns(State) {
    if(tokensBought == 0) {
      if(now >= freezeEndsAt) {
         return State.Refunding;
      } else {
        return State.Funding;
      }
    } else {
      return State.Distributing;
    }
  }

  /** Explicitly call function from your wallet. */
  function() payable {
    throw;
  }
}

    Contract ABI  
[{"constant":true,"inputs":[],"name":"weiMinimumLimit","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":false,"inputs":[],"name":"getState","outputs":[{"name":"","type":"uint8"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"getToken","outputs":[{"name":"","type":"address"}],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"balances","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"amount","type":"uint256"}],"name":"claim","outputs":[],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"investor","type":"address"}],"name":"getClaimLeft","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"investors","outputs":[{"name":"","type":"address"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"_crowdsale","type":"address"}],"name":"setCrowdsale","outputs":[],"payable":false,"type":"function"},{"constant":false,"inputs":[],"name":"refund","outputs":[],"payable":false,"type":"function"},{"constant":false,"inputs":[],"name":"halt","outputs":[],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"freezeEndsAt","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"tokensBought","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"weiCap","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"claimCount","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"name":"","type":"address"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"crowdsale","outputs":[{"name":"","type":"address"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"weiRaisedTotal","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"halted","outputs":[{"name":"","type":"bool"}],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"claimed","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":false,"inputs":[],"name":"unhalt","outputs":[],"payable":false,"type":"function"},{"constant":false,"inputs":[],"name":"claimAll","outputs":[],"payable":false,"type":"function"},{"constant":false,"inputs":[],"name":"buyForEverybody","outputs":[],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"totalClaimed","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"investorCount","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"investor","type":"address"}],"name":"getClaimAmount","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":false,"inputs":[],"name":"invest","outputs":[],"payable":true,"type":"function"},{"constant":false,"inputs":[{"name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"type":"function"},{"inputs":[{"name":"_owner","type":"address"},{"name":"_freezeEndsAt","type":"uint256"},{"name":"_weiMinimumLimit","type":"uint256"},{"name":"_weiCap","type":"uint256"}],"payable":false,"type":"constructor"},{"payable":true,"type":"fallback"},{"anonymous":false,"inputs":[{"indexed":false,"name":"investor","type":"address"},{"indexed":false,"name":"value","type":"uint256"}],"name":"Invested","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"investor","type":"address"},{"indexed":false,"name":"value","type":"uint256"}],"name":"Refunded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"count","type":"uint256"}],"name":"TokensBoughts","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"investors","type":"address"},{"indexed":false,"name":"count","type":"uint256"}],"name":"Distributed","type":"event"}]

  Contract Creation Code Switch To Opcodes View
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

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

-----Decoded View---------------
Found 4 constructor arguments :
Arg [0] : 0000000000000000000000004af893ee43a0aa328090bcf164dfa535a1619c3a
Arg [1] : 000000000000000000000000000000000000000000000000000000005956e600
Arg [2] : 0000000000000000000000000000000000000000000000022b1c8c1227a00000
Arg [3] : 000000000000000000000000000000000000000000000a968163f0a57b400000


   Swarm Source:
bzzr://f8d49c762812ec3cd724dbb61cb52c0a1605a75c2b189e74ba92d125e865fdbe

 

View All
Block Age txn Difficulty GasUsed Reward
View All
Block Age UncleNumber Difficulty GasUsed Reward
Make sure to use the "downvote" button for any spammy posts, and the "upvote" for interesting conversations.