fix uncles in head candidate

Author: heikoheiko

ethereum/blocks.py

@@ -80,6 +80,7 @@
 UNCLE_DEPTH_PENALTY_FACTOR = 8
 NEPHEW_REWARD = BLOCK_REWARD / 32
 MAX_UNCLE_DEPTH = 6  # max (block.number - uncle.number)
+MAX_UNCLES = 2
 # Difficulty adjustment constants
 DIFF_ADJUSTMENT_CUTOFF = 8
 BLOCK_DIFF_FACTOR = 2048
@@ -360,6 +361,19 @@ def to_dict(self):
         assert len(d) == len(BlockHeader.fields)
         return d
 
+    def __repr__(self):
+        return '<BlockHeader(#%d %s)>' % (self.number, encode_hex(self.hash)[:8])
+
+    def __eq__(self, other):
+        """Two blockheader are equal iff they have the same hash."""
+        return isinstance(other, BlockHeader) and self.hash == other.hash
+
+    def __hash__(self):
+        return utils.big_endian_to_int(self.hash)
+
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
 
 def mirror_from(source, attributes, only_getters=True):
     """Decorator (factory) for classes that mirror some attributes from an
@@ -646,14 +660,14 @@ def transaction_list(self):
             txs.append(self.get_transaction(i))
         return txs
 
-    def validate_uncles(self, db=None):
+    def validate_uncles(self):
         """Validate the uncles of this block."""
         if utils.sha3(rlp.encode(self.uncles)) != self.uncles_hash:
             return False
-        if len(self.uncles) > 2:
+        if len(self.uncles) > MAX_UNCLES:
             return False
         for uncle in self.uncles:
-            assert db is None or uncle.prevhash in self.db
+            assert uncle.prevhash in self.db
             if uncle.number == self.number:
                 log.error("uncle at same block height", block=self)
                 return False

ethereum/chain.py

@@ -146,31 +146,58 @@ def _update_head(self, block):
                           head_hash=block, old_head_hash=self.head)
         self.blockchain.put('HEAD', block.hash)
         self.index.update_blocknumbers(self.head)
+        self._update_head_candidate()
+        if self.new_head_cb and not block.is_genesis():
+            self.new_head_cb(block)
+
+    def _update_head_candidate(self):
+        "after new head is set"
 
-        # update head candidate
-        transactions = self.get_transactions()
-        blk = self.head
-        uncles = set(u.header for u in self.get_brothers(self.head))
-        for i in range(8):
-            for u in blk.uncles:  # assuming uncle headers
-                u = utils.sha3(rlp.encode(u))
-                if u in self:
-                    uncles.discard(self.get(u))
+        # collect uncles
+        blk = self.head  # parent of the block we are collecting uncles for
+        uncles = set(u.header for u in self.get_brothers(blk))
+        for i in range(blocks.MAX_UNCLE_DEPTH + 2):
+            for u in blk.uncles:
+                assert isinstance(u, blocks.BlockHeader)
+                uncles.discard(u)
             if blk.has_parent():
                 blk = blk.get_parent()
+        assert not uncles or max(u.number for u in uncles) <= self.head.number
+        uncles = list(uncles)[:blocks.MAX_UNCLES]
+
+        # create block
+        ts = max(int(time.time()), self.head.timestamp + 1)
+        head_candidate = blocks.Block.init_from_parent(self.head, coinbase=self._coinbase,
+                                                       timestamp=ts, uncles=uncles)
+        assert head_candidate.validate_uncles()
+
+        self.pre_finalize_state_root = head_candidate.state_root
+        head_candidate.finalize()
 
-        uncles = list(uncles)
-        ts = max(int(time.time()), block.timestamp + 1)
-        self.head_candidate = blocks.Block.init_from_parent(block, coinbase=self._coinbase,
-                                                            timestamp=ts, uncles=uncles)
-        self.pre_finalize_state_root = self.head_candidate.state_root
-        self.head_candidate.finalize()
         # add transactions from previous head candidate
-        for tx in transactions:
-            self.add_transaction(tx)
+        old_head_candidate = self.head_candidate
+        self.head_candidate = head_candidate
+        if old_head_candidate is not None:
+            for tx in old_head_candidate.get_transactions():
+                self.add_transaction(tx)
 
-        if self.new_head_cb and not block.is_genesis():
-            self.new_head_cb(block)
+    def get_uncles(self, block):
+        """Return the uncles of `block`."""
+        if not block.has_parent():
+            return []
+        else:
+            return self.get_brothers(block.get_parent())
+
+    def get_brothers(self, block):
+        """Return the uncles of the hypothetical child of `block`."""
+        o = []
+        i = 0
+        while block.has_parent() and i < blocks.MAX_UNCLE_DEPTH:
+            parent = block.get_parent()
+            o.extend([u for u in self.get_children(parent) if u != block])
+            block = block.get_parent()
+            i += 1
+        return o
 
     def get(self, blockhash):
         assert is_string(blockhash)
@@ -199,7 +226,7 @@ def add_block(self, block, forward=False):
             _log.debug('missing parent')
             return False
 
-        if not block.validate_uncles(self.db):
+        if not block.validate_uncles():
             _log.debug('invalid uncles')
             return False
 
@@ -243,24 +270,6 @@ def add_block(self, block, forward=False):
     def get_children(self, block):
         return [self.get(c) for c in self.index.get_children(block.hash)]
 
-    def get_brothers(self, block):
-        """Return the uncles of the hypothetical child of `block`."""
-        o = []
-        i = 0
-        while block.has_parent() and i < 6:
-            parent = block.get_parent()
-            o.extend([u for u in self.get_children(parent) if u != block])
-            block = parent
-            i += 1
-        return o
-
-    def get_uncles(self, block):
-        """Return the uncles of `block`."""
-        if not block.has_parent():
-            return []
-        else:
-            return self.get_brothers(block.get_parent())
-
     def add_transaction(self, transaction):
         """Add a transaction to the :attr:`head_candidate` block.