Invictus Hyperion

0xaf1250fa68d7decd34fd75de8742bc03b29bd58e

totalSupply keyboard_arrow_up

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

balanceOf keyboard_arrow_up

  function balanceOf(address _owner) public view returns (uint256 balance) {
    return balances[_owner];
  }

transfer keyboard_arrow_up

   function transfer(address _to, uint256 _value) isTradeable public returns (bool success) {
       return super.transfer(_to, _value);
   }

allowance keyboard_arrow_up

  function allowance(address _owner, address _spender) public view returns (uint256) {
    return allowed[_owner][_spender];
  }

transferFrom keyboard_arrow_up

   function transferFrom(address _from, address _to, uint256 _value) isTradeable public returns (bool success) {
       return super.transferFrom(_from, _to, _value);
   }

approve keyboard_arrow_up

  function approve(address _spender, uint256 _value) public returns (bool) {
    allowed[msg.sender][_spender] = _value;
    emit Approval(msg.sender, _spender, _value);
    return true;
  }

increaseApproval keyboard_arrow_up

  function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
    allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
    emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
    return true;
  }

decreaseApproval keyboard_arrow_up

  function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
    uint oldValue = allowed[msg.sender][_spender];
    if (_subtractedValue > oldValue) {
      allowed[msg.sender][_spender] = 0;
    } else {
      allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
    }
    emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
    return true;
  }

setVestingContract keyboard_arrow_up

  function setVestingContract(address vestingContractInput) external onlyFundWallets {
      require(!vestingSet); // can only be called once
      require(vestingContractInput != address(0));
      vestingContract = vestingContractInput;
      vestingSet = true;
  }

batchAllocate keyboard_arrow_up

  function batchAllocate(address[] participants, uint256[] values) external onlyFundWallets returns(uint256) {
      require(block.number < fundingEndBlock);
      uint256 i = 0;
      while (i < participants.length) {
        allocateTokens(participants[i], values[i]);
        i++;
      }
      return(i);
  }

adjustBalance keyboard_arrow_up

  function adjustBalance(address participant) external onlyFundWallets {
      require(vestingSet);
      require(block.number < fundingEndBlock);
      uint256 amountTokens = balances[participant];
      uint256 developmentAllocation = amountTokens.mul(25641025641025641).div(1000000000000000000);
      uint256 removeTokens = amountTokens.add(developmentAllocation);
      totalSupply_ = totalSupply_.sub(removeTokens);
      balances[participant] = 0;
      balances[vestingContract] = balances[vestingContract].sub(developmentAllocation);
      emit Transfer(participant, address(0), amountTokens);
      emit Transfer(vestingContract, address(0), developmentAllocation);
  }

changeFundWallet1 keyboard_arrow_up

  function changeFundWallet1(address newFundWallet) external onlyFundWallets {
      require(newFundWallet != address(0));
      fundWallet1 = newFundWallet;
  }

changeFundWallet2 keyboard_arrow_up

  function changeFundWallet2(address newFundWallet) external onlyFundWallets {
      require(newFundWallet != address(0));
      fundWallet2 = newFundWallet;
  }

updateFundingEndBlock keyboard_arrow_up

  function updateFundingEndBlock(uint256 newFundingEndBlock) external onlyFundWallets {
      require(block.number < fundingEndBlock);
      require(block.number < newFundingEndBlock);
      fundingEndBlock = newFundingEndBlock;
  }

enableTrading keyboard_arrow_up

  function enableTrading() external onlyFundWallets {
      require(block.number > fundingEndBlock);
      tradeable = true;
  }

constructor keyboard_arrow_up

  function() payable public {
      require(false); // throw
  }

claimTokens keyboard_arrow_up

  function claimTokens(address _token) external onlyFundWallets {
      require(_token != address(0));
      ERC20Basic token = ERC20Basic(_token);
      uint256 balance = token.balanceOf(this);
      token.transfer(fundWallet1, balance);
   }

removeEth keyboard_arrow_up

   function removeEth() external onlyFundWallets {
      fundWallet1.transfer(address(this).balance);
    }

burn keyboard_arrow_up

    function burn(uint256 _value) external onlyFundWallets {
      require(balances[msg.sender] >= _value);
      balances[msg.sender] = balances[msg.sender].sub(_value);
      balances[0x0] = balances[0x0].add(_value);
      totalSupply_ = totalSupply_.sub(_value);
      emit Transfer(msg.sender, 0x0, _value);
    }