chia-blockchain 2.5.4rc2__py3-none-any.whl → 2.5.5__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
@@ -259,7 +258,22 @@ def check_removals(
         for item in conflicting_items:
             if item in conflicts:
                 continue
-            conflict_bcs = item.bundle_coin_spends[coin_id]
+            conflict_bcs = item.bundle_coin_spends.get(coin_id)
+            if conflict_bcs is None:
+                # Check if this is an item that spends an older ff singleton
+                # version with a latest version that matches our coin ID.
+                conflict_bcs = next(
+                    (
+                        bcs
+                        for bcs in item.bundle_coin_spends.values()
+                        if bcs.latest_singleton_lineage is not None and bcs.latest_singleton_lineage.coin_id == coin_id
+                    ),
+                    None,
+                )
+                # We're not expected to get here but let's handle it gracefully
+                if conflict_bcs is None:
+                    log.warning(f"Coin ID {coin_id} expected but not found in mempool item {item.name}")
+                    return Err.INVALID_SPEND_BUNDLE, []
             # if the spend we're adding to the mempool is not DEDUP nor FF, it's
             # just a regular conflict
             if not coin_bcs.eligible_for_fast_forward and not coin_bcs.eligible_for_dedup:
@@ -362,43 +376,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 +573,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 +632,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
@@ -638,14 +640,13 @@ class MempoolManager:
                 assert eligibility_info.ff_puzzle_hash is not None
                 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
+                    mark_as_fast_forward = False
             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 +740,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,
@@ -857,7 +858,7 @@ class MempoolManager:
             # rebasing a fast forward spend is more expensive than to just
             # evict the item. So, any FF spend we may need to rebase, defer
             # them until after we've gone through all spends
-            deferred_ff_items: set[tuple[bytes32, bytes32]] = set()
+            deferred_ff_items: set[tuple[bytes32, MempoolItem]] = set()
 
             for spend in spent_coins:
                 items = self.mempool.get_items_by_coin_id(spend)
@@ -872,7 +873,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))
@@ -880,7 +881,7 @@ class MempoolManager:
                         spendbundle_ids_to_remove.add(item_name)
                         continue
 
-                    deferred_ff_items.add((spend, item_name))
+                    deferred_ff_items.add((spend, item))
 
             # fast forward spends are indexed under the latest singleton coin ID
             # if it's spent, we need to update the index in the mempool. This
@@ -888,14 +889,15 @@ class MempoolManager:
             # new_coin_id, current_coin_id, mempool item name
             spends_to_update: list[tuple[bytes32, bytes32, bytes32]] = []
 
-            for spend, item_name in deferred_ff_items:
+            for spend, item in deferred_ff_items:
+                item_name = item.spend_bundle_name
                 if item_name in spendbundle_ids_to_remove:
                     continue
                 # there may be multiple matching spends in the mempool
                 # 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 +913,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