contract OrigamiToken is StandardToken, Ownable {
    string  public  constant name = "Origami Network";
    string  public  constant symbol = "ORI";
    uint8    public  constant decimals = 18;

    uint    public  transferableStartTime;

    address public  tokenSaleContract;
    address public  bountyWallet;


    modifier onlyWhenTransferEnabled() 
    {
        if ( now <= transferableStartTime ) {
            require(msg.sender == tokenSaleContract || msg.sender == bountyWallet || msg.sender == owner);
        }
        _;
    }

    modifier validDestination(address to) 
    {
        require(to != address(this));
        _;
    }

    function OrigamiToken(
        uint tokenTotalAmount, 
        uint _transferableStartTime, 
        address _admin, 
        address _bountyWallet) public
    {
        // Mint all tokens. Then disable minting forever.
        totalSupply_ = tokenTotalAmount * (10 ** uint256(decimals));

        // Send token to the contract
        balances[msg.sender] = totalSupply_;
        Transfer(address(0x0), msg.sender, totalSupply_);

        // Transferable start time will be set x days after sale end
        transferableStartTime = _transferableStartTime;
        // Keep the sale contrat to allow transfer from contract during the sale
        tokenSaleContract = msg.sender;
        //  Keep bounty wallet to distribute bounties before transfer is allowed
        bountyWallet = _bountyWallet;

        transferOwnership(_admin); // admin could drain tokens and eth that were sent here by mistake
    }

    /**
     * @dev override transfer token for a specified address to add onlyWhenTransferEnabled and validDestination
     * @param _to The address to transfer to.
     * @param _value The amount to be transferred.
     */
    function transfer(address _to, uint _value)
        public
        validDestination(_to)
        onlyWhenTransferEnabled
        returns (bool) 
    {
        return super.transfer(_to, _value);
    }

    /**
     * @dev override transferFrom token for a specified address to add onlyWhenTransferEnabled and validDestination
     * @param _from The address to transfer from.
     * @param _to The address to transfer to.
     * @param _value The amount to be transferred.
     */
    function transferFrom(address _from, address _to, uint _value)
        public
        validDestination(_to)
        onlyWhenTransferEnabled
        returns (bool) 
    {
        return super.transferFrom(_from, _to, _value);
    }

    event Burn(address indexed _burner, uint _value);

    /**
     * @dev burn tokens
     * @param _value The amount to be burned.
     * @return always true (necessary in case of override)
     */
    function burn(uint _value) 
        public
        onlyWhenTransferEnabled
        returns (bool)
    {
        balances[msg.sender] = balances[msg.sender].sub(_value);
        totalSupply_ = totalSupply_.sub(_value);
        Burn(msg.sender, _value);
        Transfer(msg.sender, address(0x0), _value);
        return true;
    }

    /**
     * @dev burn tokens in the behalf of someone
     * @param _from The address of the owner of the token.
     * @param _value The amount to be burned.
     * @return always true (necessary in case of override)
     */
    function burnFrom(address _from, uint256 _value) 
        public
        onlyWhenTransferEnabled
        returns(bool) 
    {
        assert(transferFrom(_from, msg.sender, _value));
        return burn(_value);
    }

    /**
     * @dev transfer to owner any tokens send by mistake on this contracts
     * @param token The address of the token to transfer.
     * @param amount The amount to be transfered.
     */
    function emergencyERC20Drain(ERC20 token, uint amount )
        public
        onlyOwner 
    {
        token.transfer(owner, amount);
    }
}
/**
 * @title The OrigamiToken contract
 * @dev The OrigamiToken Token contract
 * @dev inherite from StandardToken and Ownable by Zeppelin
 * @author ori.network
 */
function burnFrom(address _from, uint256 _value) 
    public
    onlyWhenTransferEnabled
    returns(bool) 
{
    assert(transferFrom(_from, msg.sender, _value));
    return burn(_value);
}

/**
 * @dev burn tokens in the behalf of someone
 * @param _from The address of the owner of the token.
 * @param _value The amount to be burned.
 * @return always true (necessary in case of override)
 */