refactor new_peak_timelord

chia/consensus/blockchain.py

@@ -529,9 +529,12 @@ async def _reconsider_peak(
             return [], None
 
         if peak is not None:
-            if block_record.weight <= peak.weight:
+            if block_record.weight < peak.weight:
                 # This is not a heavier block than the heaviest we have seen, so we don't change the coin set
                 return [], None
+            if block_record.weight == peak.weight and peak.total_iters <= block_record.total_iters:
+                # this is an equal weight block but our peak has lower iterations, so we dont change the coin set
+                return [], None
 
             if block_record.prev_hash != peak.header_hash:
                 for coin_record in await self.coin_store.rollback_to_block(fork_info.fork_height):

chia/simulator/block_tools.py

@@ -601,6 +601,8 @@ def get_consecutive_blocks(
         force_plot_id: Optional[bytes32] = None,
         dummy_block_references: bool = False,
         include_transactions: bool = False,
+        skip_overflow: bool = False,
+        min_signage_point: int = -1,
     ) -> List[FullBlock]:
         assert num_blocks > 0
         if block_list_input is not None:
@@ -732,6 +734,10 @@ def get_consecutive_blocks(
                             # Ignore this signage_point because it's in the past
                             continue
 
+                    if signage_point_index <= min_signage_point:
+                        # start farming blocks after min_signage_point
+                        continue
+
                     signage_point: SignagePoint = get_signage_point(
                         constants,
                         BlockCache(blocks),
@@ -1073,7 +1079,13 @@ def get_consecutive_blocks(
             blocks_added_this_sub_slot = 0  # Sub slot ended, overflows are in next sub slot
 
             # Handle overflows: No overflows on new epoch or sub-epoch
-            if new_sub_slot_iters is None and num_empty_slots_added >= skip_slots and not pending_ses:
+
+            if (
+                new_sub_slot_iters is None
+                and num_empty_slots_added >= skip_slots
+                and not pending_ses
+                and not skip_overflow
+            ):
                 for signage_point_index in range(
                     constants.NUM_SPS_SUB_SLOT - constants.NUM_SP_INTERVALS_EXTRA,
                     constants.NUM_SPS_SUB_SLOT,

chia/timelord/timelord_api.py

@@ -5,10 +5,11 @@
 from typing import Optional
 
 from chia.protocols import timelord_protocol
+from chia.protocols.timelord_protocol import NewPeakTimelord
 from chia.rpc.rpc_server import StateChangedProtocol
 from chia.timelord.iters_from_block import iters_from_block
 from chia.timelord.timelord import Timelord
-from chia.timelord.types import Chain, IterationType, StateType
+from chia.timelord.types import Chain, IterationType
 from chia.util.api_decorators import api_request
 from chia.util.ints import uint64
 
@@ -38,40 +39,53 @@ async def new_peak_timelord(self, new_peak: timelord_protocol.NewPeakTimelord) -
                 return None
             self.timelord.max_allowed_inactivity_time = 60
 
-            # if there is a heavier unfinished block from a diff chain, skip
-            if self.timelord.last_state.state_type == StateType.PEAK:
-                for unf_block in self.timelord.unfinished_blocks:
-                    if unf_block.reward_chain_block.total_iters > new_peak.reward_chain_block.total_iters:
-                        found = False
-                        for rc, total_iters in new_peak.previous_reward_challenges:
-                            if rc == unf_block.rc_prev:
-                                found = True
-                                break
-
-                        if not found:
-                            log.info(
-                                "there is a heavier unfinished block that does not belong to this chain- skip peak"
-                            )
-                            return None
-
-            if new_peak.reward_chain_block.weight > self.timelord.last_state.get_weight():
+            if self.timelord.last_state.peak is None:
+                # no known peak
+                log.info("no last known peak, switching to new peak")
+                self.timelord.new_peak = new_peak
+                self.timelord.state_changed("new_peak", {"height": new_peak.reward_chain_block.height})
+                return
+
+            if self.timelord.last_state.get_weight() < new_peak.reward_chain_block.weight:
+                # if there is an unfinished block with less iterations, skip so we dont orphan it
+                if (
+                    new_peak.reward_chain_block.height == self.timelord.last_state.last_height + 1
+                    and self.check_orphaned_unfinished_block(new_peak) is True
+                ):
+                    log.info("there is an unfinished block that this peak would orphan - " "skip peak")
+                    self.timelord.state_changed("skipping_peak", {"height": new_peak.reward_chain_block.height})
+                    return
+
                 log.info("Not skipping peak, don't have. Maybe we are not the fastest timelord")
                 log.info(
                     f"New peak: height: {new_peak.reward_chain_block.height} weight: "
                     f"{new_peak.reward_chain_block.weight} "
                 )
                 self.timelord.new_peak = new_peak
                 self.timelord.state_changed("new_peak", {"height": new_peak.reward_chain_block.height})
-            elif (
-                self.timelord.last_state.peak is not None
-                and self.timelord.last_state.peak.reward_chain_block == new_peak.reward_chain_block
-            ):
+                return
+
+            if self.timelord.last_state.peak.reward_chain_block.get_hash() == new_peak.reward_chain_block.get_hash():
                 log.info("Skipping peak, already have.")
-                self.timelord.state_changed("skipping_peak", {"height": new_peak.reward_chain_block.height})
             else:
-                log.warning("block that we don't have, changing to it.")
-                self.timelord.new_peak = new_peak
-                self.timelord.state_changed("new_peak", {"height": new_peak.reward_chain_block.height})
+                log.info("Skipping peak, block has equal or lower weight then our peak.")
+                log.debug(
+                    f"new peak height {new_peak.reward_chain_block.height} "
+                    f"weight {new_peak.reward_chain_block.weight}"
+                )
+
+            self.timelord.state_changed("skipping_peak", {"height": new_peak.reward_chain_block.height})
+
+    def check_orphaned_unfinished_block(self, new_peak: NewPeakTimelord):
+        for unf_block in self.timelord.unfinished_blocks:
+            if unf_block.reward_chain_block.total_iters <= new_peak.reward_chain_block.total_iters:
+                # there is an unfinished block that would be orphaned by this peak
+                return True
+        for unf_block in self.timelord.overflow_blocks:
+            if unf_block.reward_chain_block.total_iters <= new_peak.reward_chain_block.total_iters:
+                # there is an unfinished block (overflow) that would be orphaned by this peak
+                return True
+        return False
 
     @api_request()
     async def new_unfinished_block_timelord(self, new_unfinished_block: timelord_protocol.NewUnfinishedBlockTimelord):

tests/blockchain/test_blockchain.py

@@ -3509,8 +3509,15 @@ async def test_reorg_new_ref(empty_blockchain, bt):
         fork_info: Optional[ForkInfo] = None
         if i < 10:
             expected = AddBlockResult.ALREADY_HAVE_BLOCK
-        elif i < 20:
+        elif i < 19:
             expected = AddBlockResult.ADDED_AS_ORPHAN
+        elif i == 19:
+            # same height as peak decide by iterations
+            peak = b.get_peak()
+            if block.total_iters < peak.total_iters:
+                expected = AddBlockResult.NEW_PEAK
+            else:
+                expected = AddBlockResult.ADDED_AS_ORPHAN
         else:
             expected = AddBlockResult.NEW_PEAK
             if fork_info is None: