Monolith TKN

0xaaaf91d9b90df800df4f55c205fd6989c977e73a

changeOwner keyboard_arrow_up

    function changeOwner(address _newOwner) onlyOwner {
        newOwner = _newOwner;
    }

acceptOwnership keyboard_arrow_up

    function acceptOwnership() {
        if (msg.sender == newOwner) {
            owner = newOwner;
        }
    }

Launch keyboard_arrow_up

    function Launch() onlyOwner {
        launched = true;
    }

setOwnerFreeDay keyboard_arrow_up

    function setOwnerFreeDay(uint day) onlyOwner {
        if (ownerTokensFreeDay != 0) throw;

        ownerTokensFreeDay = day;
    }

totalSupply keyboard_arrow_up

    function totalSupply() constant returns(uint) {
        return currentSupply + remainingOwner;
    }

setRemainders keyboard_arrow_up

    function setRemainders(uint _remainingOwner, uint _remainingAuctionable) onlyOwner {
        if (remaindersSet) { throw; }

        remainingOwner = _remainingOwner;
        remainingAuctionable = _remainingAuctionable;
    }

finalizeRemainders keyboard_arrow_up

    function finalizeRemainders() onlyOwner {
        remaindersSet = true;
    }

setController keyboard_arrow_up

    function setController(address _controller) onlyOwner {
        controller = _controller;
    }

claimOwnerSupply keyboard_arrow_up

    function claimOwnerSupply() onlyOwner {
        if (now < ownerTokensFreeDay) throw;
        if (remainingOwner == 0) throw;
        if (!remaindersSet) throw; // must finalize remainders

        balanceOf[owner] = safeAdd(balanceOf[owner], remainingOwner);
        remainingOwner = 0;
    }

claimAuctionableTokens keyboard_arrow_up

    function claimAuctionableTokens(uint amount) onlyController {
        if (amount > remainingAuctionable) throw;

        balanceOf[controller] = safeAdd(balanceOf[controller], amount);
        currentSupply = safeAdd(currentSupply, amount);
        remainingAuctionable = safeSub(remainingAuctionable,amount);

        Transfer(0, controller, amount);
    }

mint keyboard_arrow_up

    function mint(address addr, uint amount) onlyOwner onlyPayloadSize(2) {
        if (mintingDone) throw;

        balanceOf[addr] = safeAdd(balanceOf[addr], amount);

        currentSupply = safeAdd(currentSupply, amount);

        Transfer(0, addr, amount);
    }

multiMint keyboard_arrow_up

    function multiMint(uint[] data) onlyOwner {
        if (mintingDone) throw;

        uint supplyAdd;
        for (uint i = 0; i < data.length; i++ ) {
            address addr = address( data[i] & (D160-1) );
            uint amount = data[i] / D160;

            balanceOf[addr] += amount;
            supplyAdd += amount;
            Transfer(0, addr, amount);
        }
        currentSupply += supplyAdd;
    }

completeMinting keyboard_arrow_up

    function completeMinting() onlyOwner {
        mintingDone = true;
    }

transfer keyboard_arrow_up

    function transfer(address _to, uint _value) isLaunched notPaused
    onlyPayloadSize(2)
    returns (bool success) {
        if (balanceOf[msg.sender] < _value) return false;
        if (_to == 0x0) return false;

        balanceOf[msg.sender] = safeSub(balanceOf[msg.sender], _value);
        balanceOf[_to] = safeAdd(balanceOf[_to], _value);
        Transfer(msg.sender, _to, _value);
        return true;
    }

transferFrom keyboard_arrow_up

    function transferFrom(address _from, address _to, uint _value)  isLaunched notPaused
    onlyPayloadSize(3)
    returns (bool success) {
        if (_to == 0x0) return false;
        if (balanceOf[_from] < _value) return false;

        var allowed = allowance[_from][msg.sender];
        if (allowed < _value) return false;

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

approve keyboard_arrow_up

    function approve(address _spender, uint _value)
    onlyPayloadSize(2)
    returns (bool success) {
        //require user to set to zero before resetting to nonzero
        if ((_value != 0) && (allowance[msg.sender][_spender] != 0)) {
            return false;
        }

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

increaseApproval keyboard_arrow_up

    function increaseApproval (address _spender, uint _addedValue)
    onlyPayloadSize(2)
    returns (bool success) {
        uint oldValue = allowance[msg.sender][_spender];
        allowance[msg.sender][_spender] = safeAdd(oldValue, _addedValue);
        Approval(msg.sender, _spender, allowance[msg.sender][_spender]);
        return true;
    }

decreaseApproval keyboard_arrow_up

    function decreaseApproval (address _spender, uint _subtractedValue)
    onlyPayloadSize(2)
    returns (bool success) {
        uint oldValue = allowance[msg.sender][_spender];
        if (_subtractedValue > oldValue) {
            allowance[msg.sender][_spender] = 0;
        } else {
            allowance[msg.sender][_spender] = safeSub(oldValue, _subtractedValue);
        }
        Approval(msg.sender, _spender, allowance[msg.sender][_spender]);
        return true;
    }

approveAndCall keyboard_arrow_up

    function approveAndCall(address _spender, uint256 _amount, bytes _extraData
    ) returns (bool success) {
        if (!approve(_spender, _amount)) throw;

        ApproveAndCallFallBack(_spender).receiveApproval(
            msg.sender,
            _amount,
            this,
            _extraData
        );

        return true;
    }

lockTokenHolder keyboard_arrow_up

    function lockTokenHolder() onlyOwner {
        lockedTokenHolder = true;
    }

setTokenHolder keyboard_arrow_up

    function setTokenHolder(address _th) onlyOwner {
        if (lockedTokenHolder) throw;
        tokenholder = TokenHolder(_th);
    }

burn keyboard_arrow_up

    function burn(uint _amount) notPaused returns (bool result)  {
        if (_amount > balanceOf[msg.sender]) return false;

        balanceOf[msg.sender] = safeSub(balanceOf[msg.sender], _amount);
        currentSupply  = safeSub(currentSupply, _amount);
        result = tokenholder.burn(msg.sender, _amount);
        if (!result) throw;
        Transfer(msg.sender, 0, _amount);
    }

claimTokens keyboard_arrow_up

    function claimTokens(address _token) onlyOwner {
        if (_token == 0x0) {
            owner.transfer(this.balance);
            return;
        }

        Token token = Token(_token);
        uint balance = token.balanceOf(this);
        token.transfer(owner, balance);
        logTokenTransfer(_token, owner, balance);
    }

pause keyboard_arrow_up

    function pause() onlyOwner {
        if (pausingMechanismLocked) throw;
        paused = true;
    }

unpause keyboard_arrow_up

    function unpause() onlyOwner {
        if (pausingMechanismLocked) throw;
        paused = false;
    }

neverPauseAgain keyboard_arrow_up

    function neverPauseAgain() onlyOwner {
        pausingMechanismLocked = true;
    }