logging for possible uncles

core/block_processor.go

@@ -166,9 +166,15 @@ func (sm *BlockProcessor) processWithParent(block, parent *types.Block) (td *big
 	// Create a new state based on the parent's root (e.g., create copy)
 	state := state.New(parent.Root(), sm.db)
 
+	// track (possible) uncle block
+	var uncle bool
 	// Block validation
 	if err = sm.ValidateHeader(block.Header(), parent.Header()); err != nil {
-		return
+		if err != BlockEqualTSErr {
+			return
+		}
+		err = nil
+		uncle = true
 	}
 
 	// There can be at most two uncles
@@ -223,14 +229,22 @@ func (sm *BlockProcessor) processWithParent(block, parent *types.Block) (td *big
 	td = CalculateTD(block, parent)
 	// Sync the current block's state to the database
 	state.Sync()
-	// Remove transactions from the pool
-	sm.txpool.RemoveSet(block.Transactions())
+
+	if !uncle {
+		// Remove transactions from the pool
+		sm.txpool.RemoveSet(block.Transactions())
+	}
 
 	for _, tx := range block.Transactions() {
 		putTx(sm.extraDb, tx)
 	}
 
-	chainlogger.Infof("processed block #%d (%x...)\n", header.Number, block.Hash().Bytes()[0:4])
+	if uncle {
+		chainlogger.Infof("found possible uncle block #%d (%x...)\n", header.Number, block.Hash().Bytes()[0:4])
+		return td, nil, BlockEqualTSErr
+	} else {
+		chainlogger.Infof("processed block #%d (%x...)\n", header.Number, block.Hash().Bytes()[0:4])
+	}
 
 	return td, state.Logs(), nil
 }
@@ -255,10 +269,6 @@ func (sm *BlockProcessor) ValidateHeader(block, parent *types.Header) error {
 		return fmt.Errorf("GasLimit check failed for block %v (%v > %v)", block.GasLimit, a, b)
 	}
 
-	if block.Time <= parent.Time {
-		return ValidationError("Block timestamp equal or less than previous block (%v - %v)", block.Time, parent.Time)
-	}
-
 	if int64(block.Time) > time.Now().Unix() {
 		return BlockFutureErr
 	}
@@ -272,6 +282,10 @@ func (sm *BlockProcessor) ValidateHeader(block, parent *types.Header) error {
 		return ValidationError("Block's nonce is invalid (= %x)", block.Nonce)
 	}
 
+	if block.Time <= parent.Time {
+		return BlockEqualTSErr //ValidationError("Block timestamp equal or less than previous block (%v - %v)", block.Time, parent.Time)
+	}
+
 	return nil
 }
 
@@ -307,14 +321,10 @@ func (sm *BlockProcessor) AccumulateRewards(statedb *state.StateDB, block, paren
 			return UncleError(fmt.Sprintf("Uncle's parent unknown (%x)", uncle.ParentHash[0:4]))
 		}
 
-		if err := sm.ValidateHeader(uncle, ancestorHeaders[uncle.ParentHash]); err != nil {
+		if err := sm.ValidateHeader(uncle, ancestorHeaders[uncle.ParentHash]); err != nil && err != BlockEqualTSErr {
 			return ValidationError(fmt.Sprintf("%v", err))
 		}
 
-		if !sm.Pow.Verify(types.NewBlockWithHeader(uncle)) {
-			return ValidationError("Uncle's nonce is invalid (= %x)", uncle.Nonce)
-		}
-
 		r := new(big.Int)
 		r.Mul(BlockReward, big.NewInt(15)).Div(r, big.NewInt(16))
 

core/chain_manager.go

@@ -447,6 +447,11 @@ func (self *ChainManager) InsertChain(chain types.Blocks) error {
 				continue
 			}
 
+			if err == BlockEqualTSErr {
+				queue[i] = ChainSideEvent{block, logs}
+				continue
+			}
+
 			h := block.Header()
 			chainlogger.Infof("INVALID block #%v (%x)\n", h.Number, h.Hash().Bytes()[:4])
 			chainlogger.Infoln(err)

core/error.go

@@ -9,8 +9,9 @@ import (
 )
 
 var (
-	BlockNumberErr = errors.New("block number invalid")
-	BlockFutureErr = errors.New("block time is in the future")
+	BlockNumberErr  = errors.New("block number invalid")
+	BlockFutureErr  = errors.New("block time is in the future")
+	BlockEqualTSErr = errors.New("block time stamp equal to previous")
 )
 
 // Parent error. In case a parent is unknown this error will be thrown

miner/worker.go

@@ -131,7 +131,7 @@ out:
 				}
 			case core.NewMinedBlockEvent:
 				self.commitNewWork()
-			case core.ChainSplitEvent:
+			case core.ChainSideEvent:
 				self.uncleMu.Lock()
 				self.possibleUncles[ev.Block.Hash()] = ev.Block
 				self.uncleMu.Unlock()
@@ -170,6 +170,10 @@ func (self *worker) wait() {
 				})
 
 				if err := self.chain.InsertChain(types.Blocks{self.current.block}); err == nil {
+					for _, uncle := range self.current.block.Uncles() {
+						delete(self.possibleUncles, uncle.Hash())
+					}
+
 					self.mux.Post(core.NewMinedBlockEvent{self.current.block})
 				} else {
 					self.commitNewWork()
@@ -233,9 +237,9 @@ gasLimit:
 	}
 	self.eth.TxPool().RemoveSet(remove)
 
-	ucount := 0
+	var uncles []*types.Header
 	for hash, uncle := range self.possibleUncles {
-		if ucount == 2 {
+		if len(uncles) == 2 {
 			break
 		}
 
@@ -243,11 +247,12 @@ gasLimit:
 			minerlogger.Infof("Bad uncle found and will be removed (%x)\n", hash[:4])
 			minerlogger.Debugln(uncle)
 		} else {
-			minerlogger.Infof("Commiting %x as uncle\n", hash[:4])
-			ucount++
+			minerlogger.Infof("commiting %x as uncle\n", hash[:4])
+			uncles = append(uncles, uncle.Header())
 		}
 	}
-	minerlogger.Infoln("Included %d uncle(s)")
+	minerlogger.Infoln("Included", len(uncles), "uncle(s)")
+	self.current.block.SetUncles(uncles)
 
 	self.current.state.AddBalance(self.coinbase, core.BlockReward)
 
@@ -276,10 +281,8 @@ func (self *worker) commitUncle(uncle *types.Header) error {
 		return core.UncleError(fmt.Sprintf("Uncle already in family (%x)", uncle.Hash()))
 	}
 
-	uncleAccount := self.current.state.GetAccount(uncle.Coinbase)
-	uncleAccount.AddBalance(uncleReward)
-
-	self.current.coinbase.AddBalance(uncleReward)
+	self.current.state.AddBalance(uncle.Coinbase, uncleReward)
+	self.current.state.AddBalance(self.coinbase, inclusionReward)
 
 	return nil
 }