Cryptoindex 100
ERC20
This contract is an ERC20 token.
                Name
                
                        Cryptoindex 100
                
            
            
                Symbol
                CIX100
            
            
                Decimals
                18
            
            
                Total Supply
                300,000,000 CIX100
            
            
            
        
                About
                    
                        link
                    
                    
                        description
                    
                     
            
            
                Cryptoindex.com 100 (CIX100) is a cryptocurrency and operates on the Ethereum platform. Cryptoindex.com 100 has a current supply of 300,000,000 with 0 in circulation. The last known price of Cryptoindex.com 100 is 0.15427817 USD and is up 0.04 over the last 24 hours. It is currently trading on 1 active market(s) with $17,727.82 traded over the last 24 hours. More information can be found at https://cryptoindex.com.
            
        Stats
                Public Functions
                17
            
            
                Event Types
                7
            
            
                Code Size
                12,670 bytes
            
        Library Use
Uses SafeMath for uint.
        Events (7) keyboard_arrow_up
State Variables (20) keyboard_arrow_up
Functions
owner keyboard_arrow_up
isOwner keyboard_arrow_up
renounceOwnership keyboard_arrow_up
transferOwnership keyboard_arrow_up
Modifiers help
onlyOwner checks for the following:
null
                                Source Code
function transferOwnership(address newOwner) public onlyOwner {
  _transferOwnership(newOwner);
}
balanceOf keyboard_arrow_up
transfer keyboard_arrow_up
Requirements help
mintingIsFinished must be true
                            
                            
                    Source Code
function transfer(address _to, uint256 _amount) public returns (bool) {
  require(mintingIsFinished);
  require(_to != address(0) && _to != address(this));
  balances[msg.sender] = balances[msg.sender].sub(_amount);
  balances[_to] = balances[_to].add(_amount);
  emit Transfer(msg.sender, _to, _amount);
  return true;
}
transferFrom keyboard_arrow_up
Requirements help
mintingIsFinished must be true
                            
                            
                    Source Code
function transferFrom(
  address _from,
  address _to,
  uint256 _amount
) public returns (bool) {
  require(mintingIsFinished);
  require(_to != address(0) && _to != address(this));
  balances[_from] = balances[_from].sub(_amount);
  allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
  balances[_to] = balances[_to].add(_amount);
  emit Transfer(_from, _to, _amount);
  return true;
}
approve keyboard_arrow_up
Requirements help
One or more of the following:
                    Source Code
function approve(address _spender, uint256 _amount) public returns (bool) {
  require((_amount == 0) || (allowed[msg.sender][_spender] == 0));
  allowed[msg.sender][_spender] = _amount;
  emit Approval(msg.sender, _spender, _amount);
  return true;
}
allowance keyboard_arrow_up
startMinting keyboard_arrow_up
Modifiers help
onlyOwner checks for the following:
null
                                Source Code
function startMinting(uint256 _forgetFundValue, uint256 _bonusFundValue)
  public
  onlyOwner
{
  forgetFundValue = _forgetFundValue;
  bonusFundValue = _bonusFundValue;
  mintingIsStarted = true;
  emit MintingStarted(now);
}
finishMinting keyboard_arrow_up
Parameters help
This function has no parameters.
Modifiers help
onlyOwner checks for the following:
null
                                Requirements help
null
                            null
                            null
                            null
                            null
                    Source Code
function finishMinting() public onlyOwner {
  require(mint(forgetFund, forgetFundValue));
  uint256 currentMintedAmount = mintedAmount;
  require(mint(teamFund, currentMintedAmount.mul(teamFundPercent).div(100)));
  require(
    mint(advisorsFund, currentMintedAmount.mul(advisorsFundPercent).div(100))
  );
  require(mint(bonusFund, bonusFundValue));
  require(mint(reserveFund, totalSupply.sub(mintedAmount)));
  mintingIsFinished = true;
  emit MintingFinished(now);
}
batchTransfer keyboard_arrow_up
Requirements help
Source Code
function batchTransfer(address[] _adresses, uint256[] _values)
  public
  returns (bool)
{
  require(_adresses.length == _values.length);
  for (uint256 i = 0; i < _adresses.length; i++) {
    require(transfer(_adresses[i], _values[i]));
  }
  return true;
}
addController keyboard_arrow_up
Modifiers help
onlyOwner checks for the following:
null
                                Requirements help
mintingIsStarted must be true
                    Source Code
function addController(address _controller) public onlyOwner {
  require(mintingIsStarted);
  controllers[_controller] = true;
}
removeController keyboard_arrow_up
batchMint keyboard_arrow_up
Modifiers help
onlyController checks for the following:
Requirements help
Source Code
function batchMint(address[] _adresses, uint256[] _values)
  public
  onlyController
{
  require(_adresses.length == _values.length);
  for (uint256 i = 0; i < _adresses.length; i++) {
    require(mint(_adresses[i], _values[i]));
    emit Transfer(address(0), _adresses[i], _values[i]);
  }
}
burn keyboard_arrow_up
Source Code
function burn(address _from, uint256 _value) public {
  if (msg.sender != _from) {
    require(!mintingIsFinished);
    // burn tokens from _from only if minting stage is not finished
    // allows owner to correct initial balance before finishing minting
    require(msg.sender == this.owner());
    mintedAmount = mintedAmount.sub(_value);
  } else {
    require(mintingIsFinished);
    totalSupply = totalSupply.sub(_value);
  }
  balances[_from] = balances[_from].sub(_value);
  emit Burn(_from, _value);
}
transferAnyTokens keyboard_arrow_up
Source Code
function transferAnyTokens(address _tokenAddress, uint256 _amount)
  public
  returns (bool success)
{
  return ERC20(_tokenAddress).transfer(this.owner(), _amount);
}
Internal Functions
Internal functions are parts of the contract that can't be used directly, but instead are used by the public functions listed above.
internal CryptoIndexToken.mint keyboard_arrow_up
Requirements help
mintingIsStarted must be true
                            
                            
                    Source Code
function mint(address _to, uint256 _value) internal returns (bool) {
  // Mint tokens only if minting stage is not finished
  require(mintingIsStarted);
  require(!mintingIsFinished);
  require(mintedAmount.add(_value) <= totalSupply);
  balances[_to] = balances[_to].add(_value);
  mintedAmount = mintedAmount.add(_value);
  return true;
}
internal Ownable._transferOwnership keyboard_arrow_up
Source Code
function _transferOwnership(address newOwner) internal {
  require(newOwner != address(0));
  emit OwnershipTransferred(_owner, newOwner);
  _owner = newOwner;
}
 
         
    



