chia-blockchain 2.5.4rc2__py3-none-any.whl → 2.5.5rc1__py3-none-any.whl

chia/full_node/mempool_check_conditions.py

@@ -1,26 +1,22 @@
 from __future__ import annotations
 
 import logging
-from typing import Optional
 
 from chia_puzzles_py.programs import CHIALISP_DESERIALISATION
 from chia_rs import (
+    CoinSpend,
     ConsensusConstants,
     get_flags_for_height_and_constants,
     run_chia_program,
 )
 from chia_rs import get_puzzle_and_solution_for_coin2 as get_puzzle_and_solution_for_coin_rust
-from chia_rs.sized_bytes import bytes32
-from chia_rs.sized_ints import uint32, uint64
+from chia_rs.sized_ints import uint64
 
+from chia.consensus.condition_tools import conditions_for_solution
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
-from chia.types.coin_record import CoinRecord
-from chia.types.coin_spend import CoinSpend, CoinSpendWithConditions, SpendInfo, make_spend
+from chia.types.coin_spend import CoinSpendWithConditions, SpendInfo, make_spend
 from chia.types.generator_types import BlockGenerator
-from chia.types.spend_bundle_conditions import SpendBundleConditions
-from chia.util.condition_tools import conditions_for_solution
-from chia.util.errors import Err
 
 DESERIALIZE_MOD = Program.from_bytes(CHIALISP_DESERIALISATION)
 
@@ -61,10 +57,13 @@ def get_spends_for_block(generator: BlockGenerator, height: int, constants: Cons
     spends: list[CoinSpend] = []
 
     for spend in Program.to(ret).first().as_iter():
-        parent, puzzle, amount, solution = spend.as_iter()
-        puzzle_hash = puzzle.get_tree_hash()
-        coin = Coin(parent.as_atom(), puzzle_hash, uint64(amount.as_int()))
-        spends.append(make_spend(coin, puzzle, solution))
+        try:
+            parent, puzzle, amount, solution = spend.as_iter()
+            puzzle_hash = puzzle.get_tree_hash()
+            coin = Coin(parent.as_atom(), puzzle_hash, uint64(amount.as_int()))
+            spends.append(make_spend(coin, puzzle, solution))
+        except ValueError:
+            log.warning("get_spends_for_block() encountered a puzzle we couldn't serialize: {e}")
 
     return spends
 
@@ -90,56 +89,14 @@ def get_spends_for_block_with_conditions(
     spends: list[CoinSpendWithConditions] = []
 
     for spend in Program.to(ret).first().as_iter():
-        parent, puzzle, amount, solution = spend.as_iter()
-        puzzle_hash = puzzle.get_tree_hash()
-        coin = Coin(parent.as_atom(), puzzle_hash, uint64(amount.as_int()))
-        coin_spend = make_spend(coin, puzzle, solution)
-        conditions = conditions_for_solution(puzzle, solution, constants.MAX_BLOCK_COST_CLVM)
-        spends.append(CoinSpendWithConditions(coin_spend, conditions))
+        try:
+            parent, puzzle, amount, solution = spend.as_iter()
+            puzzle_hash = puzzle.get_tree_hash()
+            coin = Coin(parent.as_atom(), puzzle_hash, uint64(amount.as_int()))
+            coin_spend = make_spend(coin, puzzle, solution)
+            conditions = conditions_for_solution(puzzle, solution, constants.MAX_BLOCK_COST_CLVM)
+            spends.append(CoinSpendWithConditions(coin_spend, conditions))
+        except ValueError:
+            log.warning("get_spends_for_block_with_conditions() encountered a puzzle we couldn't serialize: {e}")
 
     return spends
-
-
-def mempool_check_time_locks(
-    removal_coin_records: dict[bytes32, CoinRecord],
-    bundle_conds: SpendBundleConditions,
-    prev_transaction_block_height: uint32,
-    timestamp: uint64,
-) -> Optional[Err]:
-    """
-    Check all time and height conditions against current state.
-    """
-
-    if prev_transaction_block_height < bundle_conds.height_absolute:
-        return Err.ASSERT_HEIGHT_ABSOLUTE_FAILED
-    if timestamp < bundle_conds.seconds_absolute:
-        return Err.ASSERT_SECONDS_ABSOLUTE_FAILED
-    if bundle_conds.before_height_absolute is not None:
-        if prev_transaction_block_height >= bundle_conds.before_height_absolute:
-            return Err.ASSERT_BEFORE_HEIGHT_ABSOLUTE_FAILED
-    if bundle_conds.before_seconds_absolute is not None:
-        if timestamp >= bundle_conds.before_seconds_absolute:
-            return Err.ASSERT_BEFORE_SECONDS_ABSOLUTE_FAILED
-
-    for spend in bundle_conds.spends:
-        unspent = removal_coin_records[bytes32(spend.coin_id)]
-        if spend.birth_height is not None:
-            if spend.birth_height != unspent.confirmed_block_index:
-                return Err.ASSERT_MY_BIRTH_HEIGHT_FAILED
-        if spend.birth_seconds is not None:
-            if spend.birth_seconds != unspent.timestamp:
-                return Err.ASSERT_MY_BIRTH_SECONDS_FAILED
-        if spend.height_relative is not None:
-            if prev_transaction_block_height < unspent.confirmed_block_index + spend.height_relative:
-                return Err.ASSERT_HEIGHT_RELATIVE_FAILED
-        if spend.seconds_relative is not None:
-            if timestamp < unspent.timestamp + spend.seconds_relative:
-                return Err.ASSERT_SECONDS_RELATIVE_FAILED
-        if spend.before_height_relative is not None:
-            if prev_transaction_block_height >= unspent.confirmed_block_index + spend.before_height_relative:
-                return Err.ASSERT_BEFORE_HEIGHT_RELATIVE_FAILED
-        if spend.before_seconds_relative is not None:
-            if timestamp >= unspent.timestamp + spend.before_seconds_relative:
-                return Err.ASSERT_BEFORE_SECONDS_RELATIVE_FAILED
-
-    return None

chia/full_node/mempool_manager.py

@@ -13,7 +13,8 @@ from chia_rs import (
     ELIGIBLE_FOR_FF,
     BLSCache,
     ConsensusConstants,
-    G2Element,
+    SpendBundle,
+    SpendBundleConditions,
     supports_fast_forward,
     validate_clvm_and_signature,
 )
@@ -22,23 +23,21 @@ from chia_rs.sized_ints import uint32, uint64
 from chiabip158 import PyBIP158
 
 from chia.consensus.block_record import BlockRecordProtocol
+from chia.consensus.check_time_locks import check_time_locks
 from chia.consensus.cost_calculator import NPCResult
 from chia.full_node.bitcoin_fee_estimator import create_bitcoin_fee_estimator
+from chia.full_node.eligible_coin_spends import EligibilityAndAdditions
 from chia.full_node.fee_estimation import FeeBlockInfo, MempoolInfo, MempoolItemInfo
 from chia.full_node.fee_estimator_interface import FeeEstimatorInterface
 from chia.full_node.mempool import MEMPOOL_ITEM_FEE_LIMIT, Mempool, MempoolRemoveInfo, MempoolRemoveReason
-from chia.full_node.mempool_check_conditions import mempool_check_time_locks
 from chia.full_node.pending_tx_cache import ConflictTxCache, PendingTxCache
 from chia.types.blockchain_format.coin import Coin
 from chia.types.clvm_cost import CLVMCost
 from chia.types.coin_record import CoinRecord
-from chia.types.eligible_coin_spends import EligibilityAndAdditions, UnspentLineageInfo
 from chia.types.fee_rate import FeeRate
-from chia.types.generator_types import BlockGenerator
+from chia.types.generator_types import NewBlockGenerator
 from chia.types.mempool_inclusion_status import MempoolInclusionStatus
-from chia.types.mempool_item import BundleCoinSpend, MempoolItem
-from chia.types.spend_bundle import SpendBundle
-from chia.types.spend_bundle_conditions import SpendBundleConditions
+from chia.types.mempool_item import BundleCoinSpend, MempoolItem, UnspentLineageInfo
 from chia.util.db_wrapper import SQLITE_INT_MAX
 from chia.util.errors import Err, ValidationError
 from chia.util.inline_executor import InlineExecutor
@@ -362,43 +361,30 @@ class MempoolManager:
         self.pool.shutdown(wait=True)
 
     # TODO: remove this, use create_generator() instead
-    async def create_bundle_from_mempool(
-        self,
-        last_tb_header_hash: bytes32,
-        item_inclusion_filter: Optional[Callable[[bytes32], bool]] = None,
-    ) -> Optional[tuple[SpendBundle, list[Coin]]]:
+    def create_bundle_from_mempool(self, last_tb_header_hash: bytes32) -> Optional[tuple[SpendBundle, list[Coin]]]:
         """
         Returns aggregated spendbundle that can be used for creating new block,
         additions and removals in that spend_bundle
         """
-
-        lineage_cache = LineageInfoCache(self.get_unspent_lineage_info_for_puzzle_hash)
-
         if self.peak is None or self.peak.header_hash != last_tb_header_hash:
             return None
-        return await self.mempool.create_bundle_from_mempool_items(
-            lineage_cache.get_unspent_lineage_info, self.constants, self.peak.height, item_inclusion_filter
-        )
+        return self.mempool.create_bundle_from_mempool_items(self.constants, self.peak.height)
 
-    async def create_block_generator(
-        self,
-        last_tb_header_hash: bytes32,
-        item_inclusion_filter: Optional[Callable[[bytes32], bool]] = None,
-    ) -> Optional[tuple[BlockGenerator, G2Element, list[Coin], list[Coin]]]:
+    def create_block_generator(self, last_tb_header_hash: bytes32, timeout: float) -> Optional[NewBlockGenerator]:
         """
         Returns a block generator program, the aggregate signature and all additions and removals, for a new block
         """
         if self.peak is None or self.peak.header_hash != last_tb_header_hash:
             return None
+        return self.mempool.create_block_generator(self.constants, self.peak.height, timeout)
 
-        lineage_cache = LineageInfoCache(self.get_unspent_lineage_info_for_puzzle_hash)
-
-        return await self.mempool.create_block_generator(
-            lineage_cache.get_unspent_lineage_info,
-            self.constants,
-            self.peak.height,
-            item_inclusion_filter,
-        )
+    def create_block_generator2(self, last_tb_header_hash: bytes32, timeout: float) -> Optional[NewBlockGenerator]:
+        """
+        Returns a block generator program, the aggregate signature and all additions, for a new block
+        """
+        if self.peak is None or self.peak.header_hash != last_tb_header_hash:
+            return None
+        return self.mempool.create_block_generator2(self.constants, self.peak.height, timeout)
 
     def get_filter(self) -> bytes:
         all_transactions: set[bytes32] = set()
@@ -572,12 +558,13 @@ class MempoolManager:
         get_unspent_lineage_info_for_puzzle_hash: Callable[[bytes32], Awaitable[Optional[UnspentLineageInfo]]],
     ) -> tuple[Optional[Err], Optional[MempoolItem], list[bytes32]]:
         """
-        Validates new_spend with the given NPCResult, and spend_name, and the current mempool. The mempool should
+        Validates new_spend with the given SpendBundleConditions, and
+        spend_name, and the current mempool. The mempool should
         be locked during this call (blockchain lock).
 
         Args:
             new_spend: spend bundle to validate
-            conds: result of running the clvm transaction in a fake block
+            conds: result of running the clvm transaction
             spend_name: hash of the spend bundle data, passed in as an optimization
             first_added_height: The block height that `new_spend`  first entered this node's mempool.
                 Used to estimate how long a spend has taken to be included on the chain.
@@ -630,7 +617,7 @@ class MempoolManager:
                 return Err.INVALID_COIN_SOLUTION, None, []
 
             mark_as_fast_forward = eligibility_info.ff_puzzle_hash is not None and supports_fast_forward(coin_spend)
-            latest_singleton_coin = None
+            lineage_info = None
             if mark_as_fast_forward:
                 # Make sure the fast forward spend still has a version that is
                 # still unspent, because if the singleton has been melted, the
@@ -639,13 +626,12 @@ class MempoolManager:
                 lineage_info = await get_unspent_lineage_info_for_puzzle_hash(eligibility_info.ff_puzzle_hash)
                 if lineage_info is None:
                     return Err.DOUBLE_SPEND, None, []
-                latest_singleton_coin = lineage_info.coin_id
             bundle_coin_spends[coin_id] = BundleCoinSpend(
                 coin_spend=coin_spend,
                 eligible_for_dedup=supports_dedup,
                 eligible_for_fast_forward=mark_as_fast_forward,
                 additions=eligibility_info.spend_additions,
-                latest_singleton_coin=latest_singleton_coin,
+                latest_singleton_lineage=lineage_info,
             )
 
         if removal_names != removal_names_from_coin_spends:
@@ -739,7 +725,7 @@ class MempoolManager:
         # point-of-view of the next block to be farmed. Therefore we pass in the
         # current peak's height and timestamp
         assert self.peak.timestamp is not None
-        tl_error: Optional[Err] = mempool_check_time_locks(
+        tl_error: Optional[Err] = check_time_locks(
             removal_record_dict,
             conds,
             self.peak.height,
@@ -872,7 +858,7 @@ class MempoolManager:
                         continue
 
                     bcs = item.bundle_coin_spends.get(spend)
-                    if bcs is not None and bcs.latest_singleton_coin is None:
+                    if bcs is not None and bcs.latest_singleton_lineage is None:
                         # this is a regular coin spend that's now made it into
                         # a block and we just evict its mempool item
                         included_items.append(MempoolItemInfo(item.cost, item.fee, item.height_added_to_mempool))
@@ -895,7 +881,7 @@ class MempoolManager:
                 # item, for the same singleton
                 found_matches = 0
                 for bcs in item.bundle_coin_spends.values():
-                    if bcs.latest_singleton_coin != spend:
+                    if bcs.latest_singleton_lineage is None or bcs.latest_singleton_lineage.coin_id != spend:
                         continue
                     found_matches += 1
 
@@ -911,7 +897,7 @@ class MempoolManager:
                         break
 
                     spends_to_update.append((lineage_info.coin_id, spend, item_name))
-                    bcs.latest_singleton_coin = lineage_info.coin_id
+                    bcs.latest_singleton_lineage = lineage_info
 
                 if found_matches == 0:  # pragma: no cover
                     # We are not expected to get here. this is all

chia/full_node/subscriptions.py

@@ -3,12 +3,10 @@ from __future__ import annotations
 import logging
 from dataclasses import dataclass, field
 
-from chia_rs import Coin
+from chia_rs import Coin, SpendBundleConditions
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint64
 
-from chia.types.spend_bundle_conditions import SpendBundleConditions
-
 log = logging.getLogger(__name__)
 
 

chia/full_node/tx_processing_queue.py

@@ -1,20 +1,67 @@
 from __future__ import annotations
 
 import asyncio
+import dataclasses
 import logging
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from queue import SimpleQueue
-from typing import Optional
+from typing import ClassVar, Generic, Optional, TypeVar, Union
 
+from chia_rs import SpendBundle
 from chia_rs.sized_bytes import bytes32
 
-from chia.types.transaction_queue_entry import TransactionQueueEntry
+from chia.server.ws_connection import WSChiaConnection
+from chia.types.mempool_inclusion_status import MempoolInclusionStatus
+from chia.util.errors import Err
+
+T = TypeVar("T")
 
 
 class TransactionQueueFull(Exception):
     pass
 
 
+class ValuedEventSentinel:
+    pass
+
+
+@dataclasses.dataclass
+class ValuedEvent(Generic[T]):
+    _value_sentinel: ClassVar[ValuedEventSentinel] = ValuedEventSentinel()
+
+    _event: asyncio.Event = dataclasses.field(default_factory=asyncio.Event)
+    _value: Union[ValuedEventSentinel, T] = _value_sentinel
+
+    def set(self, value: T) -> None:
+        if not isinstance(self._value, ValuedEventSentinel):
+            raise Exception("Value already set")
+        self._value = value
+        self._event.set()
+
+    async def wait(self) -> T:
+        await self._event.wait()
+        if isinstance(self._value, ValuedEventSentinel):
+            raise Exception("Value not set despite event being set")
+        return self._value
+
+
+@dataclass(frozen=True)
+class TransactionQueueEntry:
+    """
+    A transaction received from peer. This is put into a queue, and not yet in the mempool.
+    """
+
+    transaction: SpendBundle = field(compare=False)
+    transaction_bytes: Optional[bytes] = field(compare=False)
+    spend_name: bytes32
+    peer: Optional[WSChiaConnection] = field(compare=False)
+    test: bool = field(compare=False)
+    done: ValuedEvent[tuple[MempoolInclusionStatus, Optional[Err]]] = field(
+        default_factory=ValuedEvent,
+        compare=False,
+    )
+
+
 @dataclass
 class TransactionQueue:
     """

chia/full_node/weight_proof.py

@@ -10,29 +10,36 @@ from concurrent.futures.process import ProcessPoolExecutor
 from multiprocessing.context import BaseContext
 from typing import IO, Optional
 
-from chia_rs import ConsensusConstants, SubEpochChallengeSegment, SubEpochData, SubEpochSegments, SubSlotData
+from chia_rs import (
+    BlockRecord,
+    ChallengeChainSubSlot,
+    ConsensusConstants,
+    EndOfSubSlotBundle,
+    HeaderBlock,
+    RewardChainSubSlot,
+    SubEpochChallengeSegment,
+    SubEpochData,
+    SubEpochSegments,
+    SubEpochSummary,
+    SubSlotData,
+)
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint32, uint64, uint128
 
 from chia.consensus.block_header_validation import validate_finished_header_block
-from chia.consensus.block_record import BlockRecord
 from chia.consensus.blockchain_interface import BlockchainInterface
 from chia.consensus.deficit import calculate_deficit
 from chia.consensus.full_block_to_block_record import header_block_to_sub_block_record
+from chia.consensus.get_block_challenge import prev_tx_block
 from chia.consensus.pot_iterations import (
     calculate_ip_iters,
-    calculate_iterations_quality,
     calculate_sp_iters,
     is_overflow_block,
+    validate_pospace_and_get_required_iters,
 )
 from chia.consensus.vdf_info_computation import get_signage_point_vdf_info
 from chia.types.blockchain_format.classgroup import ClassgroupElement
-from chia.types.blockchain_format.proof_of_space import verify_and_get_quality_string
-from chia.types.blockchain_format.slots import ChallengeChainSubSlot, RewardChainSubSlot
-from chia.types.blockchain_format.sub_epoch_summary import SubEpochSummary
 from chia.types.blockchain_format.vdf import VDFInfo, VDFProof, validate_vdf
-from chia.types.end_of_slot_bundle import EndOfSubSlotBundle
-from chia.types.header_block import HeaderBlock
 from chia.types.validation_state import ValidationState
 from chia.types.weight_proof import (
     RecentChainData,
@@ -994,7 +1001,7 @@ def _validate_segment(
         if sampled and sub_slot_data.is_challenge():
             after_challenge = True
             required_iters = __validate_pospace(
-                constants, segment, idx, curr_difficulty, ses, first_segment_in_se, height
+                constants, segment, idx, curr_difficulty, curr_ssi, ses, first_segment_in_se, height
             )
             if required_iters is None:
                 return False, uint64(0), uint64(0), uint64(0), []
@@ -1142,7 +1149,7 @@ def sub_slot_data_vdf_input(
     if is_overflow and new_sub_slot:
         if sub_slot_idx >= 2:
             if sub_slots[sub_slot_idx - 2].cc_slot_end_info is None:
-                for ssd_idx in reversed(range(0, sub_slot_idx - 1)):
+                for ssd_idx in reversed(range(sub_slot_idx - 1)):
                     ssd = sub_slots[ssd_idx]
                     if ssd.cc_slot_end_info is not None:
                         ssd = sub_slots[ssd_idx + 1]
@@ -1157,7 +1164,7 @@ def sub_slot_data_vdf_input(
         return cc_input
 
     elif not is_overflow and not new_sub_slot:
-        for ssd_idx in reversed(range(0, sub_slot_idx)):
+        for ssd_idx in reversed(range(sub_slot_idx)):
             ssd = sub_slots[ssd_idx]
             if ssd.cc_slot_end_info is not None:
                 ssd = sub_slots[ssd_idx + 1]
@@ -1174,7 +1181,7 @@ def sub_slot_data_vdf_input(
 
     elif not new_sub_slot and is_overflow:
         slots_seen = 0
-        for ssd_idx in reversed(range(0, sub_slot_idx)):
+        for ssd_idx in reversed(range(sub_slot_idx)):
             ssd = sub_slots[ssd_idx]
             if ssd.cc_slot_end_info is not None:
                 slots_seen += 1
@@ -1239,7 +1246,7 @@ def validate_recent_blocks(
             if sub_slot.challenge_chain.new_difficulty is not None:
                 diff = sub_slot.challenge_chain.new_difficulty
 
-        if (challenge is not None) and (prev_challenge is not None):
+        if (challenge is not None) and (prev_challenge is not None) and transaction_blocks > 1:
             overflow = is_overflow_block(constants, block.reward_chain_block.signage_point_index)
             if not adjusted:
                 assert prev_block_record is not None
@@ -1260,7 +1267,9 @@ def validate_recent_blocks(
                 assert caluclated_required_iters is not None
                 required_iters = caluclated_required_iters
             else:
-                ret = _validate_pospace_recent_chain(constants, block, challenge, diff, overflow, prev_challenge)
+                ret = _validate_pospace_recent_chain(
+                    constants, sub_blocks, block, challenge, diff, ssi, overflow, prev_challenge
+                )
                 if ret is None:
                     return False, []
                 required_iters = ret
@@ -1298,9 +1307,11 @@ def validate_recent_blocks(
 
 def _validate_pospace_recent_chain(
     constants: ConsensusConstants,
+    blocks: BlockCache,
     block: HeaderBlock,
     challenge: bytes32,
     diff: uint64,
+    ssi: uint64,
     overflow: bool,
     prev_challenge: bytes32,
 ) -> Optional[uint64]:
@@ -1310,23 +1321,21 @@ def _validate_pospace_recent_chain(
     else:
         cc_sp_hash = block.reward_chain_block.challenge_chain_sp_vdf.output.get_hash()
     assert cc_sp_hash is not None
-    q_str = verify_and_get_quality_string(
-        block.reward_chain_block.proof_of_space,
+
+    required_iters = validate_pospace_and_get_required_iters(
         constants,
+        block.reward_chain_block.proof_of_space,
         challenge if not overflow else prev_challenge,
         cc_sp_hash,
-        height=block.height,
+        block.height,
+        diff,
+        ssi,
+        prev_tx_block(blocks, blocks.block_record(block.prev_header_hash)),
     )
-    if q_str is None:
+    if required_iters is None:
         log.error(f"could not verify proof of space block {block.height} {overflow}")
         return None
-    required_iters = calculate_iterations_quality(
-        constants.DIFFICULTY_CONSTANT_FACTOR,
-        q_str,
-        block.reward_chain_block.proof_of_space.size,
-        diff,
-        cc_sp_hash,
-    )
+
     return required_iters
 
 
@@ -1335,6 +1344,7 @@ def __validate_pospace(
     segment: SubEpochChallengeSegment,
     idx: int,
     curr_diff: uint64,
+    curr_sub_slot_iters: uint64,
     ses: Optional[SubEpochSummary],
     first_in_sub_epoch: bool,
     height: uint32,
@@ -1360,23 +1370,22 @@ def __validate_pospace(
 
     # validate proof of space
     assert sub_slot_data.proof_of_space is not None
-    q_str = verify_and_get_quality_string(
-        sub_slot_data.proof_of_space,
+
+    required_iters = validate_pospace_and_get_required_iters(
         constants,
+        sub_slot_data.proof_of_space,
         challenge,
         cc_sp_hash,
-        height=height,
+        height,
+        curr_diff,
+        curr_sub_slot_iters,
+        uint32(0),  # prev_tx_block(blocks, prev_b), todo need to get height of prev tx block somehow here
     )
-    if q_str is None:
+    if required_iters is None:
         log.error("could not verify proof of space")
         return None
-    return calculate_iterations_quality(
-        constants.DIFFICULTY_CONSTANT_FACTOR,
-        q_str,
-        sub_slot_data.proof_of_space.size,
-        curr_diff,
-        cc_sp_hash,
-    )
+
+    return required_iters
 
 
 def __get_rc_sub_slot(
@@ -1465,7 +1474,7 @@ def __get_rc_sub_slot(
 
 def __get_cc_sub_slot(sub_slots: list[SubSlotData], idx: int, ses: Optional[SubEpochSummary]) -> ChallengeChainSubSlot:
     sub_slot: Optional[SubSlotData] = None
-    for i in reversed(range(0, idx)):
+    for i in reversed(range(idx)):
         sub_slot = sub_slots[i]
         if sub_slot.cc_slot_end_info is not None:
             break

chia/harvester/harvester.py

@@ -36,8 +36,8 @@ from chia.plotting.util import (
     remove_plot_directory,
     update_harvester_config,
 )
+from chia.protocols.outbound_message import NodeType
 from chia.rpc.rpc_server import StateChangedProtocol, default_get_connections
-from chia.server.outbound_message import NodeType
 from chia.server.server import ChiaServer
 from chia.server.ws_connection import WSChiaConnection
 from chia.util.cpu import available_logical_cores

chia/harvester/harvester_api.py

@@ -6,23 +6,26 @@ import time
 from pathlib import Path
 from typing import TYPE_CHECKING, ClassVar, Optional, cast
 
-from chia_rs import AugSchemeMPL, G1Element, G2Element
+from chia_rs import AugSchemeMPL, G1Element, G2Element, PlotSize, ProofOfSpace
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint32, uint64
 
-from chia.consensus.pot_iterations import calculate_iterations_quality, calculate_sp_interval_iters
+from chia.consensus.pot_iterations import (
+    calculate_iterations_quality,
+    calculate_sp_interval_iters,
+)
 from chia.harvester.harvester import Harvester
 from chia.plotting.util import PlotInfo, parse_plot_info
 from chia.protocols import harvester_protocol
 from chia.protocols.farmer_protocol import FarmingInfo
 from chia.protocols.harvester_protocol import Plot, PlotSyncResponse
+from chia.protocols.outbound_message import Message, make_msg
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
 from chia.server.api_protocol import ApiMetadata
-from chia.server.outbound_message import Message, make_msg
 from chia.server.ws_connection import WSChiaConnection
 from chia.types.blockchain_format.proof_of_space import (
-    ProofOfSpace,
     calculate_pos_challenge,
+    calculate_prefix_bits,
     generate_plot_public_key,
     passes_plot_filter,
 )
@@ -144,12 +147,15 @@ class HarvesterAPI:
 
                     # Found proofs of space (on average 1 is expected per plot)
                     for index, quality_str in enumerate(quality_strings):
+                        # TODO: todo_v2_plots
                         required_iters: uint64 = calculate_iterations_quality(
-                            self.harvester.constants.DIFFICULTY_CONSTANT_FACTOR,
+                            self.harvester.constants,
                             quality_str,
-                            plot_info.prover.get_size(),
+                            PlotSize.make_v1(plot_info.prover.get_size()),
                             difficulty,
                             new_challenge.sp_hash,
+                            sub_slot_iters,
+                            new_challenge.last_tx_height,
                         )
                         sp_interval_iters = calculate_sp_interval_iters(self.harvester.constants, sub_slot_iters)
                         if required_iters < sp_interval_iters:
@@ -243,8 +249,17 @@ class HarvesterAPI:
                 # Passes the plot filter (does not check sp filter yet though, since we have not reached sp)
                 # This is being executed at the beginning of the slot
                 total += 1
+
+                # TODO: todo_v2_plots support v2 plots in PlotManager
+                filter_prefix_bits = uint8(
+                    calculate_prefix_bits(
+                        self.harvester.constants,
+                        new_challenge.peak_height,
+                        PlotSize.make_v1(try_plot_info.prover.get_size()),
+                    )
+                )
                 if passes_plot_filter(
-                    new_challenge.filter_prefix_bits,
+                    filter_prefix_bits,
                     try_plot_info.prover.get_id(),
                     new_challenge.challenge_hash,
                     new_challenge.sp_hash,

chia/introducer/introducer.py

@@ -11,9 +11,9 @@ from typing import TYPE_CHECKING, Any, ClassVar, Optional, cast
 import dns.asyncresolver
 from chia_rs.sized_ints import uint16, uint64
 
+from chia.protocols.outbound_message import NodeType
 from chia.rpc.rpc_server import StateChangedProtocol, default_get_connections
 from chia.server.introducer_peers import VettedPeer
-from chia.server.outbound_message import NodeType
 from chia.server.server import ChiaServer
 from chia.server.ws_connection import WSChiaConnection
 from chia.types.peer_info import TimestampedPeerInfo

chia/introducer/introducer_api.py

@@ -7,10 +7,10 @@ from chia_rs.sized_ints import uint64
 
 from chia.introducer.introducer import Introducer
 from chia.protocols.introducer_protocol import RequestPeersIntroducer, RespondPeersIntroducer
+from chia.protocols.outbound_message import Message, make_msg
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
 from chia.rpc.rpc_server import StateChangedProtocol
 from chia.server.api_protocol import ApiMetadata
-from chia.server.outbound_message import Message, make_msg
 from chia.server.ws_connection import WSChiaConnection
 from chia.types.peer_info import TimestampedPeerInfo
 

chia/plot_sync/exceptions.py

@@ -6,7 +6,7 @@ from chia_rs.sized_ints import uint64
 
 from chia.plot_sync.util import ErrorCodes, State
 from chia.protocols.harvester_protocol import PlotSyncIdentifier
-from chia.server.outbound_message import NodeType
+from chia.protocols.outbound_message import NodeType
 
 
 class PlotSyncException(Exception):