NeuroChain Clausius

0x5d48f293baed247a2d0189058ba37aa238bd4725

totalSupply keyboard_arrow_up

  function totalSupply() public constant returns (uint) {
    return _totalSupply;
  }

balanceOf keyboard_arrow_up

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

allowance keyboard_arrow_up

  function allowance(
    address tokenOwner,
    address spender
  )
  public constant returns (uint remaining)
  {
    return allowed[tokenOwner][spender];
  }

transfer keyboard_arrow_up

  function transfer(
    address to,
    uint tokens
  )
  public tokenTradingMustBeLive(msg.sender) returns (bool success)
  {
    balances[msg.sender] = balances[msg.sender].sub(tokens);
    balances[to] = balances[to].add(tokens);
    Transfer(msg.sender, to, tokens);
    return true;
  }

approve keyboard_arrow_up

  function approve(
    address spender,
    uint tokens
  )
  public returns (bool success)
  {
    allowed[msg.sender][spender] = tokens;
    Approval(msg.sender, spender, tokens);
    return true;
  }

transferFrom keyboard_arrow_up

  function transferFrom(
    address from,
    address to,
    uint tokens
  )
  public tokenTradingMustBeLive(from) returns (bool success)
  {
    balances[from] = balances[from].sub(tokens);
    allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
    balances[to] = balances[to].add(tokens);
    Transfer(from, to, tokens);
    return true;
  }

transferOwnership keyboard_arrow_up

    function transferOwnership(address _newOwner) public onlyOwner {
        newOwner = _newOwner;
    }

acceptOwnership keyboard_arrow_up

    function acceptOwnership() public {
        require(msg.sender == newOwner);
        OwnershipTransferred(owner, newOwner);
        owner = newOwner;
        newOwner = address(0);
    }

distributeSupply keyboard_arrow_up

  function distributeSupply(
    address to,
    uint tokens
  )
  public onlyOwner returns (bool success)
  {
    uint tokenAmount = tokens.mul(10**uint(decimals));
    require(_circulatingSupply.add(tokenAmount) <= _totalSupply);
    _circulatingSupply = _circulatingSupply.add(tokenAmount);
    balances[to] = tokenAmount;
    return true;
  }

allowFreezeBypass keyboard_arrow_up

  function allowFreezeBypass(
    address sender
  )
  public onlyOwner returns (bool success)
  {
    freezeBypassing[sender] = true;
    return true;
  }

setTradingStatus keyboard_arrow_up

  function setTradingStatus(
    bool isLive
  )
  public onlyOwner
  {
    tradingLive = isLive;
    FreezeStatusChanged(tradingLive, block.timestamp);
  }

setIcoContractAddress keyboard_arrow_up

  function setIcoContractAddress(
    address contractAddress
  )
  public onlyOwner
  {
    freezeBypassing[contractAddress] = true;
    icoContractAddress = contractAddress;
  }

setNeuroChainAddress keyboard_arrow_up

  function setNeuroChainAddress(
    string neurochainAddress
  )
  public
  {
    neuroChainAddresses[msg.sender] = neurochainAddress;
    NeuroChainAddressSet(
      msg.sender,
      neurochainAddress,
      block.timestamp,
      false
    );
  }

forceNeuroChainAddress keyboard_arrow_up

  function forceNeuroChainAddress(
    address ethAddress,
    string neurochainAddress
  )
  public onlyIcoContract
  {
    neuroChainAddresses[ethAddress] = neurochainAddress;
    NeuroChainAddressSet(
      ethAddress,
      neurochainAddress,
      block.timestamp,
      true
    );
  }

approveAndCall keyboard_arrow_up

  function approveAndCall(
    address spender,
    uint tokens,
    bytes data
  )
  public returns (bool success)
  {
    allowed[msg.sender][spender] = tokens;
    Approval(msg.sender, spender, tokens);
    ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
    return true;
  }

transferAnyERC20Token keyboard_arrow_up

  function transferAnyERC20Token(
    address tokenAddress,
    uint tokens
  )
  public onlyOwner returns (bool success)
  {
    return ERC20Interface(tokenAddress).transfer(owner, tokens);
  }