chia-blockchain 2.5.6rc2__py3-none-any.whl → 2.5.7rc2__py3-none-any.whl

chia/consensus/block_header_validation.py

@@ -138,13 +138,12 @@ def validate_unfinished_header_block(
                     if not curr.finished_challenge_slot_hashes[-1] == challenge_hash:
                         print(curr.finished_challenge_slot_hashes[-1], challenge_hash)
                         return None, ValidationError(Err.INVALID_PREV_CHALLENGE_SLOT_HASH)
-            else:
-                # 2c. check sub-slot challenge hash for empty slot
-                if (
-                    not header_block.finished_sub_slots[finished_sub_slot_n - 1].challenge_chain.get_hash()
-                    == challenge_hash
-                ):
-                    return None, ValidationError(Err.INVALID_PREV_CHALLENGE_SLOT_HASH)
+            # 2c. check sub-slot challenge hash for empty slot
+            elif (
+                not header_block.finished_sub_slots[finished_sub_slot_n - 1].challenge_chain.get_hash()
+                == challenge_hash
+            ):
+                return None, ValidationError(Err.INVALID_PREV_CHALLENGE_SLOT_HASH)
 
             if genesis_block:
                 # 2d. Validate that genesis block has no ICC
@@ -176,20 +175,19 @@ def validate_unfinished_header_block(
                             icc_vdf_input = ClassgroupElement.get_default_element()
                         else:
                             icc_vdf_input = prev_b.infused_challenge_vdf_output
-                    else:
-                        # This is not the first sub slot after the last block, so we might not have an ICC
-                        if (
-                            header_block.finished_sub_slots[finished_sub_slot_n - 1].reward_chain.deficit
-                            < constants.MIN_BLOCKS_PER_CHALLENGE_BLOCK
-                        ):
-                            finished_ss = header_block.finished_sub_slots[finished_sub_slot_n - 1]
-                            assert finished_ss.infused_challenge_chain is not None
+                    # This is not the first sub slot after the last block, so we might not have an ICC
+                    elif (
+                        header_block.finished_sub_slots[finished_sub_slot_n - 1].reward_chain.deficit
+                        < constants.MIN_BLOCKS_PER_CHALLENGE_BLOCK
+                    ):
+                        finished_ss = header_block.finished_sub_slots[finished_sub_slot_n - 1]
+                        assert finished_ss.infused_challenge_chain is not None
 
-                            # Only sets the icc iff the previous sub slots deficit is 4 or less
-                            icc_challenge_hash = finished_ss.infused_challenge_chain.get_hash()
-                            icc_iters_committed = prev_b.sub_slot_iters
-                            icc_iters_proof = icc_iters_committed
-                            icc_vdf_input = ClassgroupElement.get_default_element()
+                        # Only sets the icc iff the previous sub slots deficit is 4 or less
+                        icc_challenge_hash = finished_ss.infused_challenge_chain.get_hash()
+                        icc_iters_committed = prev_b.sub_slot_iters
+                        icc_iters_proof = icc_iters_committed
+                        icc_vdf_input = ClassgroupElement.get_default_element()
 
                 # 2e. Validate that there is not icc iff icc_challenge hash is None
                 assert (sub_slot.infused_challenge_chain is None) == (icc_challenge_hash is None)
@@ -241,10 +239,9 @@ def validate_unfinished_header_block(
                             != sub_slot.challenge_chain.infused_challenge_chain_sub_slot_hash
                         ):
                             return None, ValidationError(Err.INVALID_ICC_HASH_CC)
-                    else:
-                        # 2h. Check infused challenge sub-slot hash not included for other deficits
-                        if sub_slot.challenge_chain.infused_challenge_chain_sub_slot_hash is not None:
-                            return None, ValidationError(Err.INVALID_ICC_HASH_CC)
+                    # 2h. Check infused challenge sub-slot hash not included for other deficits
+                    elif sub_slot.challenge_chain.infused_challenge_chain_sub_slot_hash is not None:
+                        return None, ValidationError(Err.INVALID_ICC_HASH_CC)
 
                     # 2i. Check infused challenge sub-slot hash in reward sub-slot
                     if (
@@ -396,10 +393,9 @@ def validate_unfinished_header_block(
                                 f"{sub_slot.reward_chain.deficit}",
                             ),
                         )
-                else:
-                    # 2t. Otherwise, deficit stays the same at the slot ends, cannot reset until 0
-                    if sub_slot.reward_chain.deficit != prev_b.deficit:
-                        return None, ValidationError(Err.INVALID_DEFICIT, "deficit is wrong at slot end")
+                # 2t. Otherwise, deficit stays the same at the slot ends, cannot reset until 0
+                elif sub_slot.reward_chain.deficit != prev_b.deficit:
+                    return None, ValidationError(Err.INVALID_DEFICIT, "deficit is wrong at slot end")
 
         # 3. Check sub-epoch summary
         # Note that the subepoch summary is the summary of the previous subepoch (not the one that just finished)
@@ -635,16 +631,15 @@ def validate_unfinished_header_block(
             return None, ValidationError(Err.INVALID_RC_SP_VDF)
         if new_sub_slot:
             rc_sp_hash = header_block.finished_sub_slots[-1].reward_chain.get_hash()
+        elif genesis_block:
+            rc_sp_hash = constants.GENESIS_CHALLENGE
         else:
-            if genesis_block:
-                rc_sp_hash = constants.GENESIS_CHALLENGE
-            else:
-                assert prev_b is not None
-                curr = prev_b
-                while not curr.first_in_sub_slot:
-                    curr = blocks.block_record(curr.prev_hash)
-                assert curr.finished_reward_slot_hashes is not None
-                rc_sp_hash = curr.finished_reward_slot_hashes[-1]
+            assert prev_b is not None
+            curr = prev_b
+            while not curr.first_in_sub_slot:
+                curr = blocks.block_record(curr.prev_hash)
+            assert curr.finished_reward_slot_hashes is not None
+            rc_sp_hash = curr.finished_reward_slot_hashes[-1]
 
     # 12. Check reward chain sp signature
     if not AugSchemeMPL.verify(
@@ -761,25 +756,24 @@ def validate_unfinished_header_block(
             != constants.GENESIS_PRE_FARM_FARMER_PUZZLE_HASH
         ):
             return None, ValidationError(Err.INVALID_PREFARM)
+    # 20b. If pospace has a pool pk, heck pool target signature. Should not check this for genesis block.
+    elif header_block.reward_chain_block.proof_of_space.pool_public_key is not None:
+        assert header_block.reward_chain_block.proof_of_space.pool_contract_puzzle_hash is None
+        assert header_block.foliage.foliage_block_data.pool_signature is not None
+        if not AugSchemeMPL.verify(
+            header_block.reward_chain_block.proof_of_space.pool_public_key,
+            bytes(header_block.foliage.foliage_block_data.pool_target),
+            header_block.foliage.foliage_block_data.pool_signature,
+        ):
+            return None, ValidationError(Err.INVALID_POOL_SIGNATURE)
     else:
-        # 20b. If pospace has a pool pk, heck pool target signature. Should not check this for genesis block.
-        if header_block.reward_chain_block.proof_of_space.pool_public_key is not None:
-            assert header_block.reward_chain_block.proof_of_space.pool_contract_puzzle_hash is None
-            assert header_block.foliage.foliage_block_data.pool_signature is not None
-            if not AugSchemeMPL.verify(
-                header_block.reward_chain_block.proof_of_space.pool_public_key,
-                bytes(header_block.foliage.foliage_block_data.pool_target),
-                header_block.foliage.foliage_block_data.pool_signature,
-            ):
-                return None, ValidationError(Err.INVALID_POOL_SIGNATURE)
-        else:
-            # 20c. Otherwise, the plot is associated with a contract puzzle hash, not a public key
-            assert header_block.reward_chain_block.proof_of_space.pool_contract_puzzle_hash is not None
-            if (
-                header_block.foliage.foliage_block_data.pool_target.puzzle_hash
-                != header_block.reward_chain_block.proof_of_space.pool_contract_puzzle_hash
-            ):
-                return None, ValidationError(Err.INVALID_POOL_TARGET)
+        # 20c. Otherwise, the plot is associated with a contract puzzle hash, not a public key
+        assert header_block.reward_chain_block.proof_of_space.pool_contract_puzzle_hash is not None
+        if (
+            header_block.foliage.foliage_block_data.pool_target.puzzle_hash
+            != header_block.reward_chain_block.proof_of_space.pool_contract_puzzle_hash
+        ):
+            return None, ValidationError(Err.INVALID_POOL_TARGET)
 
     # 21. Check extension data if applicable. None for mainnet.
     # 22. Check if foliage block is present
@@ -928,18 +922,17 @@ def validate_finished_header_block(
     # 29. Check challenge chain infusion point VDF
     if new_sub_slot:
         cc_vdf_challenge = header_block.finished_sub_slots[-1].challenge_chain.get_hash()
+    # Not first block in slot
+    elif genesis_block:
+        # genesis block
+        cc_vdf_challenge = constants.GENESIS_CHALLENGE
     else:
-        # Not first block in slot
-        if genesis_block:
-            # genesis block
-            cc_vdf_challenge = constants.GENESIS_CHALLENGE
-        else:
-            assert prev_b is not None
-            # Not genesis block, go back to first block in slot
-            curr = prev_b
-            while curr.finished_challenge_slot_hashes is None:
-                curr = blocks.block_record(curr.prev_hash)
-            cc_vdf_challenge = curr.finished_challenge_slot_hashes[-1]
+        assert prev_b is not None
+        # Not genesis block, go back to first block in slot
+        curr = prev_b
+        while curr.finished_challenge_slot_hashes is None:
+            curr = blocks.block_record(curr.prev_hash)
+        cc_vdf_challenge = curr.finished_challenge_slot_hashes[-1]
 
     cc_target_vdf_info = VDFInfo(
         cc_vdf_challenge,
@@ -1047,9 +1040,8 @@ def validate_finished_header_block(
                 icc_target_vdf_info,
             ):
                 return None, ValidationError(Err.INVALID_ICC_VDF, "invalid icc proof")
-    else:
-        if header_block.infused_challenge_chain_ip_proof is not None:
-            return None, ValidationError(Err.INVALID_ICC_VDF)
+    elif header_block.infused_challenge_chain_ip_proof is not None:
+        return None, ValidationError(Err.INVALID_ICC_VDF)
 
     # 32. Check reward block hash
     if header_block.foliage.reward_block_hash != header_block.reward_chain_block.get_hash():

chia/{full_node → consensus}/block_height_map.py

@@ -10,6 +10,7 @@ from chia_rs import SubEpochSummary
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32
 
+from chia.consensus.block_height_map_protocol import BlockHeightMapProtocol
 from chia.util.db_wrapper import DBWrapper2
 from chia.util.files import write_file_async
 from chia.util.streamable import Streamable, streamable
@@ -23,7 +24,7 @@ class SesCache(Streamable):
     content: list[tuple[uint32, bytes]]
 
 
-class BlockHeightMap:
+class BlockHeightMap(BlockHeightMapProtocol):
     db: DBWrapper2
 
     # the below dictionaries are loaded from the database, from the peak

chia/consensus/block_height_map_protocol.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from typing import Optional, Protocol
+
+from chia_rs import SubEpochSummary
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint32
+
+
+class BlockHeightMapProtocol(Protocol):
+    def update_height(self, height: uint32, header_hash: bytes32, ses: Optional[SubEpochSummary]) -> None: ...
+
+    def get_hash(self, height: uint32) -> bytes32: ...
+
+    def contains_height(self, height: uint32) -> bool: ...
+
+    def rollback(self, fork_height: int) -> None: ...
+
+    def get_ses(self, height: uint32) -> SubEpochSummary: ...
+
+    def get_ses_heights(self) -> list[uint32]: ...

chia/consensus/block_rewards.py

@@ -17,17 +17,17 @@ def calculate_pool_reward(height: uint32) -> uint64:
     """
 
     if height == 0:
-        return uint64(int((7 / 8) * 21000000 * _mojo_per_chia))
+        return uint64((7 / 8) * 21000000 * _mojo_per_chia)
     elif height < 3 * _blocks_per_year:
-        return uint64(int((7 / 8) * 2 * _mojo_per_chia))
+        return uint64((7 / 8) * 2 * _mojo_per_chia)
     elif height < 6 * _blocks_per_year:
-        return uint64(int((7 / 8) * 1 * _mojo_per_chia))
+        return uint64((7 / 8) * 1 * _mojo_per_chia)
     elif height < 9 * _blocks_per_year:
-        return uint64(int((7 / 8) * 0.5 * _mojo_per_chia))
+        return uint64((7 / 8) * 0.5 * _mojo_per_chia)
     elif height < 12 * _blocks_per_year:
-        return uint64(int((7 / 8) * 0.25 * _mojo_per_chia))
+        return uint64((7 / 8) * 0.25 * _mojo_per_chia)
     else:
-        return uint64(int((7 / 8) * 0.125 * _mojo_per_chia))
+        return uint64((7 / 8) * 0.125 * _mojo_per_chia)
 
 
 def calculate_base_farmer_reward(height: uint32) -> uint64:
@@ -40,14 +40,14 @@ def calculate_base_farmer_reward(height: uint32) -> uint64:
     rates increase continuously.
     """
     if height == 0:
-        return uint64(int((1 / 8) * 21000000 * _mojo_per_chia))
+        return uint64((1 / 8) * 21000000 * _mojo_per_chia)
     elif height < 3 * _blocks_per_year:
-        return uint64(int((1 / 8) * 2 * _mojo_per_chia))
+        return uint64((1 / 8) * 2 * _mojo_per_chia)
     elif height < 6 * _blocks_per_year:
-        return uint64(int((1 / 8) * 1 * _mojo_per_chia))
+        return uint64((1 / 8) * 1 * _mojo_per_chia)
     elif height < 9 * _blocks_per_year:
-        return uint64(int((1 / 8) * 0.5 * _mojo_per_chia))
+        return uint64((1 / 8) * 0.5 * _mojo_per_chia)
     elif height < 12 * _blocks_per_year:
-        return uint64(int((1 / 8) * 0.25 * _mojo_per_chia))
+        return uint64((1 / 8) * 0.25 * _mojo_per_chia)
     else:
-        return uint64(int((1 / 8) * 0.125 * _mojo_per_chia))
+        return uint64((1 / 8) * 0.125 * _mojo_per_chia)

chia/consensus/blockchain.py

@@ -26,6 +26,7 @@ from chia_rs.sized_ints import uint16, uint32, uint64, uint128
 
 from chia.consensus.block_body_validation import ForkInfo, validate_block_body
 from chia.consensus.block_header_validation import validate_unfinished_header_block
+from chia.consensus.block_height_map import BlockHeightMap
 from chia.consensus.coin_store_protocol import CoinStoreProtocol
 from chia.consensus.cost_calculator import NPCResult
 from chia.consensus.difficulty_adjustment import get_next_sub_slot_iters_and_difficulty
@@ -34,7 +35,6 @@ from chia.consensus.full_block_to_block_record import block_to_block_record
 from chia.consensus.generator_tools import get_block_header
 from chia.consensus.get_block_generator import get_block_generator
 from chia.consensus.multiprocess_validation import PreValidationResult
-from chia.full_node.block_height_map import BlockHeightMap
 from chia.full_node.block_store import BlockStore
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.vdf import VDFInfo
@@ -421,7 +421,7 @@ class Blockchain:
 
         try:
             # Always add the block to the database
-            async with self.block_store.db_wrapper.writer():
+            async with self.block_store.transaction():
                 # Perform the DB operations to update the state, and rollback if something goes wrong
                 await self.block_store.add_full_block(header_hash, block, block_record)
                 records, state_change_summary = await self._reconsider_peak(block_record, genesis, fork_info)
@@ -708,9 +708,8 @@ class Blockchain:
             if block.transactions_generator is not None:
                 if std_hash(bytes(block.transactions_generator)) != block.transactions_info.generator_root:
                     return None, Err.INVALID_TRANSACTIONS_GENERATOR_HASH
-            else:
-                if block.transactions_info.generator_root != bytes([0] * 32):
-                    return None, Err.INVALID_TRANSACTIONS_GENERATOR_HASH
+            elif block.transactions_info.generator_root != bytes([0] * 32):
+                return None, Err.INVALID_TRANSACTIONS_GENERATOR_HASH
 
             if (
                 block.foliage_transaction_block is None
@@ -883,7 +882,7 @@ class Blockchain:
 
         blocks: list[FullBlock] = []
         for hash in hashes.copy():
-            block = self.block_store.block_cache.get(hash)
+            block = self.block_store.get_block_from_cache(hash)
             if block is not None:
                 blocks.append(block)
                 hashes.remove(hash)
@@ -926,27 +925,18 @@ class Blockchain:
             return None
         return header_dict[header_hash]
 
-    async def get_block_records_at(self, heights: list[uint32], batch_size: int = 900) -> list[BlockRecord]:
+    async def get_block_records_at(self, heights: list[uint32]) -> list[BlockRecord]:
         """
         gets block records by height (only blocks that are part of the chain)
         """
-        records: list[BlockRecord] = []
         hashes: list[bytes32] = []
-        assert batch_size < self.block_store.db_wrapper.host_parameter_limit
         for height in heights:
             header_hash: Optional[bytes32] = self.height_to_hash(height)
             if header_hash is None:
                 raise ValueError(f"Do not have block at height {height}")
             hashes.append(header_hash)
-            if len(hashes) > batch_size:
-                res = await self.block_store.get_block_records_by_hash(hashes)
-                records.extend(res)
-                hashes = []
-
-        if len(hashes) > 0:
-            res = await self.block_store.get_block_records_by_hash(hashes)
-            records.extend(res)
-        return records
+
+        return await self.block_store.get_block_records_by_hash(hashes)
 
     def try_block_record(self, header_hash: bytes32) -> Optional[BlockRecord]:
         if header_hash in self.__block_records:

chia/consensus/default_constants.py

@@ -91,12 +91,12 @@ DEFAULT_CONSTANTS = ConsensusConstants(
     PLOT_FILTER_64_HEIGHT=uint32(15592000),
     # June 2033
     PLOT_FILTER_32_HEIGHT=uint32(20643000),
-    PLOT_DIFFICULTY_INITIAL=uint8(2),
-    PLOT_DIFFICULTY_4_HEIGHT=uint32(0xFFFFFFFB),
-    PLOT_DIFFICULTY_5_HEIGHT=uint32(0xFFFFFFFC),
-    PLOT_DIFFICULTY_6_HEIGHT=uint32(0xFFFFFFFD),
-    PLOT_DIFFICULTY_7_HEIGHT=uint32(0xFFFFFFFE),
-    PLOT_DIFFICULTY_8_HEIGHT=uint32(0xFFFFFFFF),
+    PLOT_STRENGTH_INITIAL=uint8(2),
+    PLOT_STRENGTH_4_HEIGHT=uint32(0xFFFFFFFB),
+    PLOT_STRENGTH_5_HEIGHT=uint32(0xFFFFFFFC),
+    PLOT_STRENGTH_6_HEIGHT=uint32(0xFFFFFFFD),
+    PLOT_STRENGTH_7_HEIGHT=uint32(0xFFFFFFFE),
+    PLOT_STRENGTH_8_HEIGHT=uint32(0xFFFFFFFF),
 )
 
 

chia/consensus/generator_tools.py

@@ -65,6 +65,6 @@ def tx_removals_and_additions(results: Optional[SpendBundleConditions]) -> tuple
     for spend in results.spends:
         removals.append(bytes32(spend.coin_id))
         for puzzle_hash, amount, _ in spend.create_coin:
-            additions.append(Coin(bytes32(spend.coin_id), bytes32(puzzle_hash), uint64(amount)))
+            additions.append(Coin(spend.coin_id, puzzle_hash, uint64(amount)))
 
     return removals, additions

chia/consensus/get_block_challenge.py

@@ -72,34 +72,33 @@ def get_block_challenge(
         else:
             # No overflow, new slot with a new challenge
             challenge = header_block.finished_sub_slots[-1].challenge_chain.get_hash()
+    elif genesis_block:
+        challenge = constants.GENESIS_CHALLENGE
     else:
-        if genesis_block:
-            challenge = constants.GENESIS_CHALLENGE
-        else:
-            if overflow:
-                if skip_overflow_last_ss_validation:
-                    # Overflow infusion without the new slot, so get the last challenge
-                    challenges_to_look_for = 1
-                else:
-                    # Overflow infusion, so get the second to last challenge. skip_overflow_last_ss_validation is False,
-                    # Which means no sub slots are omitted
-                    challenges_to_look_for = 2
-            else:
+        if overflow:
+            if skip_overflow_last_ss_validation:
+                # Overflow infusion without the new slot, so get the last challenge
                 challenges_to_look_for = 1
-            reversed_challenge_hashes: list[bytes32] = []
-            curr: BlockRecord = blocks.block_record(header_block.prev_header_hash)
-            while len(reversed_challenge_hashes) < challenges_to_look_for:
-                if curr.first_in_sub_slot:
-                    assert curr.finished_challenge_slot_hashes is not None
-                    reversed_challenge_hashes += reversed(curr.finished_challenge_slot_hashes)
-                    if len(reversed_challenge_hashes) >= challenges_to_look_for:
-                        break
-                if curr.height == 0:
-                    assert curr.finished_challenge_slot_hashes is not None
-                    assert len(curr.finished_challenge_slot_hashes) > 0
+            else:
+                # Overflow infusion, so get the second to last challenge. skip_overflow_last_ss_validation is False,
+                # Which means no sub slots are omitted
+                challenges_to_look_for = 2
+        else:
+            challenges_to_look_for = 1
+        reversed_challenge_hashes: list[bytes32] = []
+        curr: BlockRecord = blocks.block_record(header_block.prev_header_hash)
+        while len(reversed_challenge_hashes) < challenges_to_look_for:
+            if curr.first_in_sub_slot:
+                assert curr.finished_challenge_slot_hashes is not None
+                reversed_challenge_hashes += reversed(curr.finished_challenge_slot_hashes)
+                if len(reversed_challenge_hashes) >= challenges_to_look_for:
                     break
-                curr = blocks.block_record(curr.prev_hash)
-            challenge = reversed_challenge_hashes[challenges_to_look_for - 1]
+            if curr.height == 0:
+                assert curr.finished_challenge_slot_hashes is not None
+                assert len(curr.finished_challenge_slot_hashes) > 0
+                break
+            curr = blocks.block_record(curr.prev_hash)
+        challenge = reversed_challenge_hashes[challenges_to_look_for - 1]
     return challenge
 
 

chia/consensus/pos_quality.py

@@ -1,13 +1,28 @@
 from __future__ import annotations
 
+from chia_rs import PlotSize
 from chia_rs.sized_ints import uint64
 
 # The actual space in bytes of a plot, is _expected_plot_size(k) * UI_ACTUAL_SPACE_CONSTANT_FACTO
 # This is not used in consensus, only for display purposes
 UI_ACTUAL_SPACE_CONSTANT_FACTOR = 0.78
 
+# TODO: todo_v2_plots these values prelimenary. When the plotter is complete,
+# replace this table with a closed form formula
+v2_plot_sizes: dict[int, uint64] = {
+    16: uint64(222_863),
+    18: uint64(1_048_737),
+    20: uint64(4_824_084),
+    22: uint64(21_812_958),
+    24: uint64(97_318_160),
+    26: uint64(429_539_960),
+    28: uint64(1_879_213_114),
+    30: uint64(8_161_097_549),
+    32: uint64(35_221_370_574),
+}
 
-def _expected_plot_size(k: int) -> uint64:
+
+def _expected_plot_size(size: PlotSize) -> uint64:
     """
     Given the plot size parameter k (which is between 32 and 59), computes the
     expected size of the plot in bytes (times a constant factor). This is based on efficient encoding
@@ -16,4 +31,15 @@ def _expected_plot_size(k: int) -> uint64:
     is necessary to store the entries in the plot.
     """
 
-    return uint64(((2 * k) + 1) * (2 ** (k - 1)))
+    k: int
+    if size.size_v1 is not None:
+        k = size.size_v1
+        return uint64(((2 * k) + 1) * (2 ** (k - 1)))
+    else:
+        assert size.size_v2 is not None
+        k = size.size_v2
+        if k in v2_plot_sizes:
+            return v2_plot_sizes[k]
+        else:
+            # TODO: todo_v2_plots support test plots with lower k-values
+            return uint64(0)

chia/consensus/pot_iterations.py

@@ -10,9 +10,6 @@ from chia.consensus.pos_quality import _expected_plot_size
 from chia.types.blockchain_format.proof_of_space import verify_and_get_quality_string
 from chia.util.hash import std_hash
 
-# TODO: todo_v2_plots add to chia_rs and get from constants
-PHASE_OUT_PERIOD = uint32(10000000)
-
 
 def is_overflow_block(constants: ConsensusConstants, signage_point_index: uint8) -> bool:
     if signage_point_index >= constants.NUM_SPS_SUB_SLOT:
@@ -38,7 +35,7 @@ def calculate_phase_out(
 ) -> uint64:
     if prev_transaction_block_height <= constants.HARD_FORK2_HEIGHT:
         return uint64(0)
-    elif uint32(prev_transaction_block_height - constants.HARD_FORK2_HEIGHT) >= PHASE_OUT_PERIOD:
+    elif uint32(prev_transaction_block_height - constants.HARD_FORK2_HEIGHT) >= constants.PLOT_V1_PHASE_OUT:
         return uint64(calculate_sp_interval_iters(constants, sub_slot_iters))
 
     return uint64(
@@ -46,7 +43,7 @@ def calculate_phase_out(
             uint32(prev_transaction_block_height - constants.HARD_FORK2_HEIGHT)
             * calculate_sp_interval_iters(constants, sub_slot_iters)
         )
-        // PHASE_OUT_PERIOD
+        // constants.PLOT_V1_PHASE_OUT
     )
 
 
@@ -113,17 +110,18 @@ def calculate_iterations_quality(
     """
     if size.size_v1 is not None:
         assert size.size_v2 is None
-        sp_quality_string: bytes32 = std_hash(quality_string + cc_sp_output_hash)
         phase_out = calculate_phase_out(constants, ssi, prev_transaction_block_height)
-        iters = uint64(
-            (
-                int(difficulty)
-                * int(constants.DIFFICULTY_CONSTANT_FACTOR)
-                * int.from_bytes(sp_quality_string, "big", signed=False)
-                // (int(pow(2, 256)) * int(_expected_plot_size(size.size_v1)))
-            )
-            + phase_out
-        )
-        return max(iters, uint64(1))
     else:
-        raise NotImplementedError
+        phase_out = uint64(0)
+
+    sp_quality_string: bytes32 = std_hash(quality_string + cc_sp_output_hash)
+    iters = uint64(
+        (
+            int(difficulty)
+            * int(constants.DIFFICULTY_CONSTANT_FACTOR)
+            * int.from_bytes(sp_quality_string, "big", signed=False)
+            // (int(pow(2, 256)) * int(_expected_plot_size(size)))
+        )
+        + phase_out
+    )
+    return max(iters, uint64(1))

chia/daemon/keychain_proxy.py

@@ -384,6 +384,11 @@ class KeychainProxy(DaemonProxy):
                     self.log.error(f"{err}")
                     raise KeychainMalformedResponse(f"{err}")
                 elif private:
+                    if ent is None:
+                        err = f"Missing ent in {response.get('command')} response"
+                        self.log.error(f"{err}")
+                        raise KeychainMalformedResponse(f"{err}")
+
                     mnemonic = bytes_to_mnemonic(bytes.fromhex(ent))
                     seed = mnemonic_to_seed(mnemonic)
                     private_key = AugSchemeMPL.key_gen(seed)

chia/daemon/server.py

@@ -1373,9 +1373,8 @@ class WebSocketServer:
                 "service": service,
                 "queue": self.extract_plot_queue(),
             }
-        else:
-            if self.ping_job is None:
-                self.ping_job = create_referenced_task(self.ping_task())
+        elif self.ping_job is None:
+            self.ping_job = create_referenced_task(self.ping_task())
         self.log.info(f"registered for service {service}")
         log.info(f"{response}")
         return response