blocktrade.com

0xfa456cf55250a839088b27ee32a424d7dacb54ff

transferOwnership keyboard_arrow_up

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

editRestrictedAddress keyboard_arrow_up

  function editRestrictedAddress(address _restrictedAddress, bool _restrict) public onlyOwner{
    if(!restrictedAddresses[_restrictedAddress] && _restrict){
      restrictedAddresses[_restrictedAddress] = _restrict;
    }
    else if(restrictedAddresses[_restrictedAddress] && !_restrict){
      restrictedAddresses[_restrictedAddress] = _restrict;
    }
    else{
      revert();
    }
  }

tokenName keyboard_arrow_up

  function tokenName() constant public returns(string _tokenName){
    return name;
  }

tokenSymbol keyboard_arrow_up

  function tokenSymbol() constant public returns(string _tokenSymbol){
    return symbol;
  }

tokenDecimals keyboard_arrow_up

  function tokenDecimals() constant public returns(uint8 _tokenDecimals){
    return decimals;
  }

totalSupply keyboard_arrow_up

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

balanceOf keyboard_arrow_up

  function balanceOf(address _tokenOwner) constant public returns(uint256 accountBalance){
    return balances[_tokenOwner];
  }

allowance keyboard_arrow_up

  function allowance(address _owner, address _spender) constant public returns(uint256 remaining) {
    return allowances[_owner][_spender];
  }

getFreezeUntilDetails keyboard_arrow_up

  function getFreezeUntilDetails() constant public returns(uint256 frozenUntilBlock, string notice){
    return(tokenFrozenUntilBlock, tokenFrozenUntilNotice);
  }

getFreezeSinceDetails keyboard_arrow_up

  function getFreezeSinceDetails() constant public returns(uint frozenSinceBlock, string notice){
    return(tokenFrozenSinceBlock, tokenFrozenSinceNotice);
  }

isRestrictedAddress keyboard_arrow_up

  function isRestrictedAddress(address _queryAddress) constant public returns(bool answer){
    return restrictedAddresses[_queryAddress];
  }

transfer keyboard_arrow_up

  function transfer(address _to, uint256 _value) unfrozenToken instForbiddenAddress(_to) public returns(bool success){
    require(balances[msg.sender] >= _value);           // Check if the sender has enough
    require(balances[_to] + _value >= balances[_to]) ;  // Check for overflows

    balances[msg.sender] -= _value;                     // Subtract from the sender
    balances[_to] += _value;                            // Add the same to the recipient
    emit Transfer(msg.sender, _to, _value);                  // Notify anyone listening that this transfer took place
    return true;
  }

approve keyboard_arrow_up

  function approve(address _spender, uint256 _value) unfrozenToken public returns (bool success){
    allowances[msg.sender][_spender] = _value;          // Set allowance
    emit Approval(msg.sender, _spender, _value);             // Raise Approval event
    return true;
  }

transferFrom keyboard_arrow_up

  function transferFrom(address _from, address _to, uint256 _value) unfrozenToken instForbiddenAddress(_to) public returns(bool success){
    require(balances[_from] >= _value);                // Check if the sender has enough
    require(balances[_to] + _value >= balances[_to]);  // Check for overflows
    require(_value <= allowances[_from][msg.sender]);  // Check allowance

    balances[_from] -= _value;                          // Subtract from the sender
    balances[_to] += _value;                            // Add the same to the recipient
    allowances[_from][msg.sender] -= _value;            // Deduct allowance for this address
    emit Transfer(_from, _to, _value);                       // Notify anyone listening that this transfer took place
    return true;
  }

burn keyboard_arrow_up

  function burn(uint256 _value) onlyOwner public returns(bool success){
    require(balances[msg.sender] >= _value);                 // Check if the sender has enough
    balances[msg.sender] -= _value;                          // Subtract from the sender
    supply -= _value;
    emit Burn(msg.sender, _value);
    return true;
  }

freezeTransfersUntil keyboard_arrow_up

  function freezeTransfersUntil(uint256 _frozenUntilBlock, string _freezeNotice) onlyOwner public returns(bool success){
    tokenFrozenUntilBlock = _frozenUntilBlock;
    tokenFrozenUntilNotice = _freezeNotice;
    emit TokenFrozenUntil(_frozenUntilBlock, _freezeNotice);
    return true;
  }

freezeTransfersSince keyboard_arrow_up

  function freezeTransfersSince(uint256 _frozenSinceBlock, string _freezeNotice) onlyOwner public returns(bool success){
    tokenFrozenSinceBlock = _frozenSinceBlock;
    tokenFrozenSinceNotice = _freezeNotice;
    emit TokenFrozenSince(_frozenSinceBlock, _freezeNotice);
    return true;
  }

unfreezeTransfersUntil keyboard_arrow_up

  function unfreezeTransfersUntil(string _unfreezeNotice) onlyOwner public returns(bool success){
    tokenFrozenUntilBlock = 0;
    tokenFrozenUntilNotice = _unfreezeNotice;
    emit TokenFrozenUntil(0, _unfreezeNotice);
    return true;
  }

unfreezeTransfersSince keyboard_arrow_up

  function unfreezeTransfersSince(string _unfreezeNotice) onlyOwner public returns(bool success){
    tokenFrozenSinceBlock = (2 ** 256) - 1;
    tokenFrozenSinceNotice = _unfreezeNotice;
    emit TokenFrozenSince((2 ** 256) - 1, _unfreezeNotice);
    return true;
  }

airDrop keyboard_arrow_up

  function airDrop(address _beneficiary, uint256 _tokens) onlyOwner public returns(bool success){
    require(!airDropFinished);
    balances[owner] -= _tokens;
    balances[_beneficiary] += _tokens;
    return true;
  }

endAirDrop keyboard_arrow_up

  function endAirDrop() onlyOwner public returns(bool success){
    require(!airDropFinished);
    airDropFinished = true;
    return true;
  }