function addOwner(address owner)
         public
         onlyWallet
         ownerDoesNotExist(owner)
         notNull(owner)
         validRequirement(owners.length + 1, required)
     {
         isOwner[owner] = true;
         owners.push(owner);
         OwnerAddition(owner);
     }
 

     function removeOwner(address owner)
         public
         onlyWallet
         ownerExists(owner)
     {
         isOwner[owner] = false;
         for (uint i=0; i<owners.length - 1; i++)
             if (owners[i] == owner) {
                 owners[i] = owners[owners.length - 1];
                 break;
             }
         owners.length -= 1;
         if (required > owners.length)
             changeRequirement(owners.length);
         OwnerRemoval(owner);
     }
 

     function replaceOwner(address owner, address newOwner)
         public
         onlyWallet
         ownerExists(owner)
         ownerDoesNotExist(newOwner)
     {
         for (uint i=0; i<owners.length; i++)
             if (owners[i] == owner) {
                 owners[i] = newOwner;
                 break;
             }
         isOwner[owner] = false;
         isOwner[newOwner] = true;
         OwnerRemoval(owner);
         OwnerAddition(newOwner);
     }
 

     function changeRequirement(uint _required)
         public
         onlyWallet
         validRequirement(owners.length, _required)
     {
         required = _required;
         RequirementChange(_required);
     }
 

     function submitTransaction(address destination, uint value, bytes data)
         public
         returns (uint transactionId)
     {
         transactionId = addTransaction(destination, value, data);
         confirmTransaction(transactionId);
     }
 

     function getConfirmations(uint transactionId)
         public
         constant
         returns (address[] _confirmations)
     {
         address[] memory confirmationsTemp = new address[](owners.length);
         uint count = 0;
         uint i;
         for (i=0; i<owners.length; i++)
             if (confirmations[transactionId][owners[i]]) {
                 confirmationsTemp[count] = owners[i];
                 count += 1;
             }
         _confirmations = new address[](count);
         for (i=0; i<count; i++)
             _confirmations[i] = confirmationsTemp[i];
     }
 

     function getTransactionIds(uint from, uint to, bool pending, bool executed)
         public
         constant
         returns (uint[] _transactionIds)
     {
         uint[] memory transactionIdsTemp = new uint[](transactionCount);
         uint count = 0;
         uint i;
         for (i=0; i<transactionCount; i++)
             if (   pending && !transactions[i].executed
                 || executed && transactions[i].executed)
             {
                 transactionIdsTemp[count] = i;
                 count += 1;
             }
         _transactionIds = new uint[](to - from);
         for (i=from; i<to; i++)
             _transactionIds[i - from] = transactionIdsTemp[i];
     }
 

     function getOwners()
         public
         constant
         returns (address[])
     {
         return owners;
     }
 

     function getConfirmationCount(uint transactionId)
         public
         constant
         returns (uint count)
     {
         for (uint i=0; i<owners.length; i++)
             if (confirmations[transactionId][owners[i]])
                 count += 1;
     }
 

     function isConfirmed(uint transactionId)
         public
         constant
         returns (bool)
     {
         uint count = 0;
         for (uint i=0; i<owners.length; i++) {
             if (confirmations[transactionId][owners[i]])
                 count += 1;
             if (count == required)
                 return true;
         }
     }
 

     function getTransactionCount(bool pending, bool executed)
         public
         constant
         returns (uint count)
     {
         for (uint i=0; i<transactionCount; i++)
             if (   pending && !transactions[i].executed
                 || executed && transactions[i].executed)
                 count += 1;
     }
 

     event RequirementChange(uint required);
 

     event OwnerRemoval(address indexed owner);
 

     event OwnerAddition(address indexed owner);
 

     event Deposit(address indexed sender, uint value);
 

     event ExecutionFailure(uint indexed transactionId);
 

     event Execution(uint indexed transactionId);
 

     event Submission(uint indexed transactionId);
 

     event Revocation(address indexed sender, uint indexed transactionId);
 

     event Confirmation(address indexed sender, uint indexed transactionId);
 

     function executeTransaction(uint transactionId)
         public
         notExecuted(transactionId)
         fullyConfirmed(transactionId)
         pastTimeLock(transactionId)
     {
         Transaction storage tx = transactions[transactionId];
         tx.executed = true;
         if (tx.destination.call.value(tx.value)(tx.data))
             Execution(transactionId);
         else {
             ExecutionFailure(transactionId);
             tx.executed = false;
         }
     }
 

     function changeTimeLock(uint _secondsTimeLocked)
         public
         onlyWallet
     {
         secondsTimeLocked = _secondsTimeLocked;
         TimeLockChange(_secondsTimeLocked);
     }
 

     function revokeConfirmation(uint transactionId)
         public
         ownerExists(msg.sender)
         confirmed(transactionId, msg.sender)
         notExecuted(transactionId)
         notFullyConfirmed(transactionId)
     {
         confirmations[transactionId][msg.sender] = false;
         Revocation(msg.sender, transactionId);
     }
 

     function confirmTransaction(uint transactionId)
         public
         ownerExists(msg.sender)
         transactionExists(transactionId)
         notConfirmed(transactionId, msg.sender)
         notFullyConfirmed(transactionId)
     {
         confirmations[transactionId][msg.sender] = true;
         Confirmation(msg.sender, transactionId);
         if (isConfirmed(transactionId)) {
             setConfirmationTime(transactionId, block.timestamp);
         }
     }
 

     event TimeLockChange(uint secondsTimeLocked);
 

     event ConfirmationTimeSet(uint indexed transactionId, uint confirmationTime);
 

     function executeRemoveAuthorizedAddress(uint transactionId)
         public
         notExecuted(transactionId)
         fullyConfirmed(transactionId)
         validRemoveAuthorizedAddressTx(transactionId)
     {
         Transaction storage tx = transactions[transactionId];
         tx.executed = true;
         if (tx.destination.call.value(tx.value)(tx.data))
             Execution(transactionId);
         else {
             ExecutionFailure(transactionId);
             tx.executed = false;
         }
     }
 

     function isFunctionRemoveAuthorizedAddress(bytes data)
         public
         constant
         returns (bool)
     {
         bytes4 removeAuthorizedAddressSignature = bytes4(sha3("removeAuthorizedAddress(address)"));
         for (uint i = 0; i < 4; i++) {
             require(data[i] == removeAuthorizedAddressSignature[i]);
         }
         return true;
     }
 

     function MultiSigWalletWithTimeLockExceptRemoveAuthorizedAddress(
         address[] _owners,
         uint _required,
         uint _secondsTimeLocked,
         address _tokenTransferProxy)
         public
         MultiSigWalletWithTimeLock(_owners, _required, _secondsTimeLocked)
     {
         TOKEN_TRANSFER_PROXY_CONTRACT = _tokenTransferProxy;
     }
 

     uint public required;
 

     uint constant public MAX_OWNER_COUNT = 50;
 

     mapping (uint => uint) public confirmationTimes;
 

     uint public transactionCount;
 

     address public TOKEN_TRANSFER_PROXY_CONTRACT;
 

     mapping (uint => Transaction) public transactions;
 

     uint public secondsTimeLocked;
 

     mapping (uint => mapping (address => bool)) public confirmations;
 

     mapping (address => bool) public isOwner;
 

     address[] public owners;