1 files changed, 25 insertions, 22 deletions

diff --git a/ethchain/transaction_pool.go b/ethchain/transaction_pool.go
index fdc386303..72836d6cb 100644
--- a/ethchain/transaction_pool.go
+++ b/ethchain/transaction_pool.go
@@ -90,7 +90,7 @@ func (pool *TxPool) addTransaction(tx *Transaction) {
 
 // Process transaction validates the Tx and processes funds from the
 // sender to the recipient.
-func (pool *TxPool) ProcessTransaction(tx *Transaction, block *Block) (err error) {
+func (pool *TxPool) ProcessTransaction(tx *Transaction, block *Block, toContract bool) (err error) {
 	defer func() {
 		if r := recover(); r != nil {
 			log.Println(r)
@@ -100,19 +100,15 @@ func (pool *TxPool) ProcessTransaction(tx *Transaction, block *Block) (err error
 	// Get the sender
 	sender := block.state.GetAccount(tx.Sender())
 
+	if sender.Nonce != tx.Nonce {
+		return fmt.Errorf("[TXPL] Invalid account nonce, state nonce is %d transaction nonce is %d instead", sender.Nonce, tx.Nonce)
+	}
+
 	// Make sure there's enough in the sender's account. Having insufficient
 	// funds won't invalidate this transaction but simple ignores it.
 	totAmount := new(big.Int).Add(tx.Value, new(big.Int).Mul(TxFee, TxFeeRat))
 	if sender.Amount.Cmp(totAmount) < 0 {
-		return errors.New("Insufficient amount in sender's account")
-	}
-
-	if sender.Nonce != tx.Nonce {
-		if ethutil.Config.Debug {
-			return fmt.Errorf("Invalid nonce %d(%d) continueing anyway", tx.Nonce, sender.Nonce)
-		} else {
-			return fmt.Errorf("Invalid nonce %d(%d)", tx.Nonce, sender.Nonce)
-		}
+		return fmt.Errorf("[TXPL] Insufficient amount in sender's (%x) account", tx.Sender())
 	}
 
 	// Get the receiver
@@ -122,22 +118,21 @@ func (pool *TxPool) ProcessTransaction(tx *Transaction, block *Block) (err error
 	// Send Tx to self
 	if bytes.Compare(tx.Recipient, tx.Sender()) == 0 {
 		// Subtract the fee
-		sender.Amount.Sub(sender.Amount, new(big.Int).Mul(TxFee, TxFeeRat))
+		sender.SubAmount(new(big.Int).Mul(TxFee, TxFeeRat))
 	} else {
 		// Subtract the amount from the senders account
-		sender.Amount.Sub(sender.Amount, totAmount)
+		sender.SubAmount(totAmount)
 
 		// Add the amount to receivers account which should conclude this transaction
-		receiver.Amount.Add(receiver.Amount, tx.Value)
+		receiver.AddAmount(tx.Value)
 
-		block.state.UpdateAccount(tx.Recipient, receiver)
+		block.state.UpdateStateObject(receiver)
 	}
 
-	block.state.UpdateAccount(tx.Sender(), sender)
+	block.state.UpdateStateObject(sender)
 
 	log.Printf("[TXPL] Processed Tx %x\n", tx.Hash())
 
-	// Notify the subscribers
 	pool.notifySubscribers(TxPost, tx)
 
 	return
@@ -149,18 +144,18 @@ func (pool *TxPool) ValidateTransaction(tx *Transaction) error {
 	block := pool.Ethereum.BlockChain().CurrentBlock
 	// Something has gone horribly wrong if this happens
 	if block == nil {
-		return errors.New("No last block on the block chain")
+		return errors.New("[TXPL] No last block on the block chain")
 	}
 
 	// Get the sender
 	accountState := pool.Ethereum.StateManager().GetAddrState(tx.Sender())
-	sender := accountState.Account
+	sender := accountState.Object
 
 	totAmount := new(big.Int).Add(tx.Value, new(big.Int).Mul(TxFee, TxFeeRat))
 	// Make sure there's enough in the sender's account. Having insufficient
 	// funds won't invalidate this transaction but simple ignores it.
 	if sender.Amount.Cmp(totAmount) < 0 {
-		return fmt.Errorf("Insufficient amount in sender's (%x) account", tx.Sender())
+		return fmt.Errorf("[TXPL] Insufficient amount in sender's (%x) account", tx.Sender())
 	}
 
 	// Increment the nonce making each tx valid only once to prevent replay
@@ -190,11 +185,13 @@ out:
 					log.Println("Validating Tx failed", err)
 				}
 			} else {
-				// Call blocking version. At this point it
-				// doesn't matter since this is a goroutine
+				// Call blocking version.
 				pool.addTransaction(tx)
 
 				// Notify the subscribers
+				pool.Ethereum.Reactor().Post("newTx", tx)
+
+				// Notify the subscribers
 				pool.notifySubscribers(TxPre, tx)
 			}
 		case <-pool.quit:
@@ -207,7 +204,7 @@ func (pool *TxPool) QueueTransaction(tx *Transaction) {
 	pool.queueChan <- tx
 }
 
-func (pool *TxPool) Flush() []*Transaction {
+func (pool *TxPool) CurrentTransactions() []*Transaction {
 	pool.mutex.Lock()
 	defer pool.mutex.Unlock()
 
@@ -221,6 +218,12 @@ func (pool *TxPool) Flush() []*Transaction {
 		i++
 	}
 
+	return txList
+}
+
+func (pool *TxPool) Flush() []*Transaction {
+	txList := pool.CurrentTransactions()
+
 	// Recreate a new list all together
 	// XXX Is this the fastest way?
 	pool.pool = list.New()