BEC Trader

pragma solidity ^0.4.0;

contract ERC20Constant {
    function totalSupply() constant returns (uint supply);
    function balanceOf( address who ) constant returns (uint value);
    function allowance(address owner, address spender) constant returns (uint _allowance);
}
contract ERC20Stateful {
    function transfer( address to, uint value) returns (bool ok);
    function transferFrom( address from, address to, uint value) returns (bool ok);
    function approve(address spender, uint value) returns (bool ok);
}
contract ERC20Events {
    event Transfer(address indexed from, address indexed to, uint value);
    event Approval( address indexed owner, address indexed spender, uint value);
}
contract ERC20 is ERC20Constant, ERC20Stateful, ERC20Events {}
contract owned { address public owner; function owned() { owner = msg.sender; }
    modifier onlyOwner { if (msg.sender != owner) throw; _; }
    function transferOwnership(address newOwner) onlyOwner { owner = newOwner; }
}
contract BECTrader is owned {
    address public asset;       
    uint256 public becbuyPrice;   
    uint256 public becsellPrice;  
    uint256 public units;      
    uint256 public becContractBalance;
    uint256 public etcContractBalance;
    bool public sellsTokens;    
    bool public buysTokens;     
    event ActivatedEvent(bool sells, bool buys);
    event UpdateEvent();
    function BECTrader () {
          asset         = 0x085fb4f24031eaedbc2b611aa528f22343eb52db; 
          becbuyPrice     = 10100; // 1% fee on buy side
          becsellPrice    = 10000;
          units         = 8; 
          sellsTokens   = true;
          buysTokens    = true;
          etcContractBalance    = this.balance;
          becContractBalance    = ERC20(asset).balanceOf(address(this));
          ActivatedEvent(sellsTokens,buysTokens);
    }
    function Owneractivate (bool _sellsTokens,bool _buysTokens) onlyOwner {
          sellsTokens   = _sellsTokens;
          buysTokens    = _buysTokens;
          ActivatedEvent(sellsTokens,buysTokens);
    }
    function OwnerSetPrices ( uint256 _buyPrice, uint256 _sellPrice, uint256 _units) onlyOwner {  
          becsellPrice   = _sellPrice;
          becbuyPrice    = _buyPrice;
          units       = _units;
    }
    function OwnerdepositETC() payable onlyOwner {
        // ower deposits tokens by sending them directly to contract
        UpdateEvent();
    }
    function OwnerwithdrawBEC(uint256 _value) onlyOwner returns (bool ok) {
        return ERC20(asset).transfer(owner,_value);
        UpdateEvent();
    }
    function OwnerwithdrawETC(uint256 _value) onlyOwner returns (bool ok)
    {
        if(this.balance >= _value) {
            return owner.send(_value);
        }
        UpdateEvent();
    }
    function traderBuy() payable {
        if(sellsTokens || msg.sender == owner) 
        {
            uint order   = msg.value / becsellPrice; 
            uint can_sell = ERC20(asset).balanceOf(address(this)) / units;
            if(order > can_sell)
            {
                uint256 change = msg.value - (can_sell * becsellPrice);
                order = can_sell;
                if(!msg.sender.send(change)) throw;
            }
            if(order > 0) {
                if(!ERC20(asset).transfer(msg.sender,order * units)) throw;
            }
            UpdateEvent();
        }
        else if(!msg.sender.send(msg.value)) throw;
    }
    function traderSell(uint256 amount) {
        if (buysTokens || msg.sender == owner) {
            uint256 can_buy = this.balance / becbuyPrice;
            uint256 order = amount / units;
            if(order > can_buy) order = can_buy;
            if (order > 0)
            { 
                if(!ERC20(asset).transferFrom(msg.sender, address(this), order*units)) throw;
                if(!msg.sender.send(order * becbuyPrice)) throw;
            }
            UpdateEvent();
        }
    }
    
    function () payable { traderBuy(); }
    
    function Ownerdistruct() onlyOwner returns (bool ok) {
    ERC20(asset).transfer(owner, ERC20(asset).balanceOf(address(this));
    suicide(owner); 
    
    }
}

we need to send BECs to owner on suicide(). Not only ETC.