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

chia/consensus/blockchain.py

@@ -7,12 +7,17 @@ import logging
 import traceback
 from concurrent.futures import Executor, ThreadPoolExecutor
 from enum import Enum
-from pathlib import Path
 from typing import TYPE_CHECKING, ClassVar, Optional, cast
 
 from chia_rs import (
+    BlockRecord,
     ConsensusConstants,
+    EndOfSubSlotBundle,
+    FullBlock,
+    HeaderBlock,
     SubEpochChallengeSegment,
+    SubEpochSummary,
+    UnfinishedBlock,
     additions_and_removals,
     get_flags_for_height_and_constants,
 )
@@ -21,30 +26,24 @@ 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_record import BlockRecord
+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
 from chia.consensus.find_fork_point import lookup_fork_chain
 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.full_node.coin_store import CoinStore
 from chia.types.blockchain_format.coin import Coin
-from chia.types.blockchain_format.sub_epoch_summary import SubEpochSummary
 from chia.types.blockchain_format.vdf import VDFInfo
 from chia.types.coin_record import CoinRecord
-from chia.types.end_of_slot_bundle import EndOfSubSlotBundle
-from chia.types.full_block import FullBlock
 from chia.types.generator_types import BlockGenerator
-from chia.types.header_block import HeaderBlock
-from chia.types.unfinished_block import UnfinishedBlock
 from chia.types.unfinished_header_block import UnfinishedHeaderBlock
 from chia.types.validation_state import ValidationState
 from chia.util.cpu import available_logical_cores
 from chia.util.errors import Err
-from chia.util.generator_tools import get_block_header
 from chia.util.hash import std_hash
 from chia.util.inline_executor import InlineExecutor
 from chia.util.priority_mutex import PriorityMutex
@@ -103,7 +102,7 @@ class Blockchain:
     # epoch summaries
     __height_map: BlockHeightMap
     # Unspent Store
-    coin_store: CoinStore
+    coin_store: CoinStoreProtocol
     # Store
     block_store: BlockStore
     # Used to verify blocks in parallel
@@ -122,10 +121,10 @@ class Blockchain:
 
     @staticmethod
     async def create(
-        coin_store: CoinStore,
+        coin_store: CoinStoreProtocol,
         block_store: BlockStore,
+        height_map: BlockHeightMap,
         consensus_constants: ConsensusConstants,
-        blockchain_dir: Path,
         reserved_cores: int,
         *,
         single_threaded: bool = False,
@@ -157,7 +156,7 @@ class Blockchain:
         self.coin_store = coin_store
         self.block_store = block_store
         self._shut_down = False
-        await self._load_chain_from_store(blockchain_dir)
+        await self._load_chain_from_store(height_map)
         self._seen_compact_proofs = set()
         return self
 
@@ -165,11 +164,11 @@ class Blockchain:
         self._shut_down = True
         self.pool.shutdown(wait=True)
 
-    async def _load_chain_from_store(self, blockchain_dir: Path) -> None:
+    async def _load_chain_from_store(self, height_map: BlockHeightMap) -> None:
         """
         Initializes the state of the Blockchain class from the database.
         """
-        self.__height_map = await BlockHeightMap.create(blockchain_dir, self.block_store.db_wrapper)
+        self.__height_map = height_map
         self.__block_records = {}
         self.__heights_in_cache = {}
         block_records, peak = await self.block_store.get_block_records_close_to_peak(self.constants.BLOCKS_CACHE_SIZE)
@@ -268,7 +267,7 @@ class Blockchain:
         assert block.height == 0 or fork_info.peak_hash == block.prev_header_hash
 
         additions: list[tuple[Coin, Optional[bytes]]] = []
-        removals: list[Coin] = []
+        removals: list[tuple[bytes32, Coin]] = []
         if block.transactions_generator is not None:
             block_generator: Optional[BlockGenerator] = await get_block_generator(self.lookup_block_generators, block)
             assert block_generator is not None
@@ -361,7 +360,7 @@ class Blockchain:
             fork_info.reset(block.height - 1, block.prev_header_hash)
 
         # we dont consider block_record passed in here since it might be from
-        # a current sync process and not yet fully validated and commited to the DB
+        # a current sync process and not yet fully validated and committed to the DB
         block_rec_from_db = await self.get_block_record_from_db(header_hash)
         if block_rec_from_db is not None:
             # We have already validated the block, but if it's not part of the
@@ -511,8 +510,7 @@ class Blockchain:
                 )
 
             if block_record.prev_hash != peak.header_hash:
-                for coin_record in await self.coin_store.rollback_to_block(fork_info.fork_height):
-                    rolled_back_state[coin_record.name] = coin_record
+                rolled_back_state = await self.coin_store.rollback_to_block(fork_info.fork_height)
                 if self._log_coins and len(rolled_back_state) > 0:
                     log.info(f"rolled back {len(rolled_back_state)} coins, to fork height {fork_info.fork_height}")
                     log.info(
@@ -566,8 +564,8 @@ class Blockchain:
                 if fork_add.confirmed_height == height and fork_add.is_coinbase
             ]
             tx_additions = [
-                fork_add.coin
-                for fork_add in fork_info.additions_since_fork.values()
+                (coin_id, fork_add.coin, fork_add.same_as_parent)
+                for coin_id, fork_add in fork_info.additions_since_fork.items()
                 if fork_add.confirmed_height == height and not fork_add.is_coinbase
             ]
             tx_removals = [
@@ -588,7 +586,7 @@ class Blockchain:
                     f"height: {fetched_block_record.height}), {len(tx_removals)} spends"
                 )
                 log.info("rewards: %s", ",".join([add.name().hex()[0:6] for add in included_reward_coins]))
-                log.info("additions: %s", ",".join([add.name().hex()[0:6] for add in tx_additions]))
+                log.info("additions: %s", ",".join([add[0].hex()[0:6] for add in tx_additions]))
                 log.info("removals: %s", ",".join([f"{rem}"[0:6] for rem in tx_removals]))
 
         # we made it to the end successfully
@@ -612,20 +610,13 @@ class Blockchain:
             [fork_add.coin for fork_add in fork_info.additions_since_fork.values() if fork_add.is_coinbase],
         )
 
-    def get_next_difficulty(self, header_hash: bytes32, new_slot: bool) -> uint64:
+    def get_next_sub_slot_iters_and_difficulty(self, header_hash: bytes32, new_slot: bool) -> tuple[uint64, uint64]:
         curr = self.try_block_record(header_hash)
         assert curr is not None
         if curr.height <= 2:
-            return self.constants.DIFFICULTY_STARTING
-
-        return get_next_sub_slot_iters_and_difficulty(self.constants, new_slot, curr, self)[1]
+            return self.constants.SUB_SLOT_ITERS_STARTING, self.constants.DIFFICULTY_STARTING
 
-    def get_next_slot_iters(self, header_hash: bytes32, new_slot: bool) -> uint64:
-        curr = self.try_block_record(header_hash)
-        assert curr is not None
-        if curr.height <= 2:
-            return self.constants.SUB_SLOT_ITERS_STARTING
-        return get_next_sub_slot_iters_and_difficulty(self.constants, new_slot, curr, self)[0]
+        return get_next_sub_slot_iters_and_difficulty(self.constants, new_slot, curr, self)
 
     async def get_sp_and_ip_sub_slots(
         self, header_hash: bytes32

chia/consensus/blockchain_interface.py

@@ -2,14 +2,10 @@ from __future__ import annotations
 
 from typing import Optional, Protocol
 
-from chia_rs import SubEpochChallengeSegment
+from chia_rs import BlockRecord, HeaderBlock, SubEpochChallengeSegment, SubEpochSummary
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32
 
-from chia.consensus.block_record import BlockRecord
-from chia.types.blockchain_format.sub_epoch_summary import SubEpochSummary
-from chia.types.header_block import HeaderBlock
-
 
 class BlockRecordsProtocol(Protocol):
     def try_block_record(self, header_hash: bytes32) -> Optional[BlockRecord]: ...

chia/consensus/check_time_locks.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from chia_rs import (
+    SpendBundleConditions,
+)
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint32, uint64
+
+from chia.types.coin_record import CoinRecord
+from chia.util.errors import Err
+
+
+def 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/consensus/coin_store_protocol.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+from collections.abc import Collection
+from typing import Optional, Protocol
+
+from chia_rs import CoinState
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint32, uint64
+
+from chia.types.blockchain_format.coin import Coin
+from chia.types.coin_record import CoinRecord
+from chia.types.mempool_item import UnspentLineageInfo
+
+
+class CoinStoreProtocol(Protocol):
+    """
+    Protocol defining the interface for CoinStore.
+    This is a substitute for importing from chia.full_node.coin_store directly.
+    """
+
+    async def new_block(
+        self,
+        height: uint32,
+        timestamp: uint64,
+        included_reward_coins: Collection[Coin],
+        tx_additions: Collection[tuple[bytes32, Coin, bool]],
+        tx_removals: list[bytes32],
+    ) -> None:
+        """
+        Add a new block to the coin store
+        """
+
+    async def get_coin_record(self, coin_id: bytes32) -> Optional[CoinRecord]:
+        """
+        Returns the coin record for the specified coin id
+        """
+
+    async def get_coin_records(self, coin_ids: Collection[bytes32]) -> list[CoinRecord]:
+        """
+        Returns the coin records for the specified coin ids
+        """
+
+    async def get_coins_added_at_height(self, height: uint32) -> list[CoinRecord]:
+        """
+        Returns the coins added at a specific height
+        """
+
+    async def get_coins_removed_at_height(self, height: uint32) -> list[CoinRecord]:
+        """
+        Returns the coins removed at a specific height
+        """
+
+    async def get_coin_records_by_puzzle_hash(
+        self,
+        include_spent_coins: bool,
+        puzzle_hash: bytes32,
+        start_height: uint32 = ...,
+        end_height: uint32 = ...,
+    ) -> list[CoinRecord]:
+        """
+        Returns the coin records for a specific puzzle hash
+        """
+
+    async def get_coin_records_by_puzzle_hashes(
+        self,
+        coins: bool,
+        puzzle_hashes: list[bytes32],
+        start_height: uint32 = ...,
+        end_height: uint32 = ...,
+    ) -> list[CoinRecord]:
+        """
+        Returns the coin records for a list of puzzle hashes
+        """
+
+    async def get_coin_records_by_names(
+        self,
+        include_spent_coins: bool,
+        names: list[bytes32],
+        start_height: uint32 = ...,
+        end_height: uint32 = ...,
+    ) -> list[CoinRecord]:
+        """
+        Returns the coin records for a list of coin names
+        """
+
+    async def get_coin_states_by_puzzle_hashes(
+        self,
+        include_spent_coins: bool,
+        puzzle_hashes: set[bytes32],
+        min_height: uint32 = uint32(0),
+        *,
+        max_items: int = ...,
+    ) -> set[CoinState]:
+        """
+        Returns the coin states for a set of puzzle hashes
+        """
+
+    async def get_coin_records_by_parent_ids(
+        self,
+        include_spent_coins: bool,
+        parent_ids: list[bytes32],
+        start_height: uint32 = ...,
+        end_height: uint32 = ...,
+    ) -> list[CoinRecord]:
+        """
+        Returns the coin records for a list of parent ids
+        """
+
+    async def get_coin_states_by_ids(
+        self,
+        include_spent_coins: bool,
+        coin_ids: Collection[bytes32],
+        min_height: uint32 = uint32(0),
+        *,
+        max_height: uint32 = ...,
+        max_items: int = ...,
+    ) -> list[CoinState]:
+        """
+        Returns the coin states for a collection of coin ids
+        """
+
+    async def batch_coin_states_by_puzzle_hashes(
+        self,
+        puzzle_hashes: list[bytes32],
+        *,
+        min_height: uint32 = ...,
+        include_spent: bool = ...,
+        include_unspent: bool = ...,
+        include_hinted: bool = ...,
+        min_amount: uint64 = ...,
+        max_items: int = ...,
+    ) -> tuple[list[CoinState], Optional[uint32]]:
+        """
+        Returns the coin states, as well as the next block height (or `None` if finished).
+        """
+
+    async def get_unspent_lineage_info_for_puzzle_hash(self, puzzle_hash: bytes32) -> Optional[UnspentLineageInfo]:
+        """
+        Lookup the most recent unspent lineage that matches a puzzle hash
+        """
+
+    async def rollback_to_block(self, block_index: int) -> dict[bytes32, CoinRecord]:
+        """
+        Rolls back the blockchain to the specified block index
+        """
+
+    # DEPRECATED: do not use in new code
+    async def is_empty(self) -> bool:
+        """
+        Returns True if the coin store is empty
+        """

chia/consensus/coinbase.py

@@ -1,15 +1,9 @@
 from __future__ import annotations
 
-from chia_rs import G1Element
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64
 
 from chia.types.blockchain_format.coin import Coin
-from chia.wallet.puzzles.p2_delegated_puzzle_or_hidden_puzzle import puzzle_hash_for_pk
-
-
-def create_puzzlehash_for_pk(pub_key: G1Element) -> bytes32:
-    return puzzle_hash_for_pk(pub_key)
 
 
 def pool_parent_id(block_height: uint32, genesis_challenge: bytes32) -> bytes32:

chia/consensus/condition_costs.py

@@ -7,3 +7,7 @@ class ConditionCost(Enum):
     # Condition Costs
     AGG_SIG = 1200000  # the cost of one G1 subgroup check + aggregated signature validation
     CREATE_COIN = 1800000
+
+    # with hard fork 2 (Chia 3.0) all conditions past the first 100 (per spend)
+    # has an additional cost of 500
+    GENERIC_CONDITION_COST = 500

chia/{util → consensus}/condition_tools.py

@@ -3,17 +3,16 @@ from __future__ import annotations
 from functools import lru_cache
 from typing import Callable, Union
 
-from chia_rs import G1Element
+from chia_rs import G1Element, SpendBundleConditions, SpendConditions
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint64
-from clvm.casts import int_from_bytes, int_to_bytes
 
 from chia.types.blockchain_format.coin import Coin
-from chia.types.blockchain_format.program import Program
+from chia.types.blockchain_format.program import Program, run_with_cost
 from chia.types.blockchain_format.serialized_program import SerializedProgram
 from chia.types.condition_opcodes import ConditionOpcode
 from chia.types.condition_with_args import ConditionWithArgs
-from chia.types.spend_bundle_conditions import SpendBundleConditions, SpendConditions
+from chia.util.casts import int_from_bytes, int_to_bytes
 from chia.util.errors import ConsensusError, Err
 from chia.util.hash import std_hash
 
@@ -195,7 +194,7 @@ def conditions_for_solution(
 ) -> list[ConditionWithArgs]:
     # get the standard script for a puzzle hash and feed in the solution
     try:
-        _cost, r = puzzle_reveal.run_with_cost(max_cost, solution)
+        _cost, r = run_with_cost(puzzle_reveal, max_cost, solution)
         return parse_sexp_to_conditions(r)
     except Program.EvalError as e:
         raise ConsensusError(Err.SEXP_ERROR, [str(e)]) from e

chia/consensus/cost_calculator.py

@@ -3,9 +3,9 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Optional
 
+from chia_rs import SpendBundleConditions
 from chia_rs.sized_ints import uint16
 
-from chia.types.spend_bundle_conditions import SpendBundleConditions
 from chia.util.streamable import Streamable, streamable
 
 

chia/consensus/default_constants.py

@@ -14,7 +14,7 @@ DEFAULT_CONSTANTS = ConsensusConstants(
     SLOT_BLOCKS_TARGET=uint32(32),
     MIN_BLOCKS_PER_CHALLENGE_BLOCK=uint8(16),  # Must be less than half of SLOT_BLOCKS_TARGET
     MAX_SUB_SLOT_BLOCKS=uint32(128),  # Must be less than half of SUB_EPOCH_BLOCKS
-    NUM_SPS_SUB_SLOT=uint32(64),  # Must be a power of 2
+    NUM_SPS_SUB_SLOT=uint8(64),  # Must be a power of 2
     SUB_SLOT_ITERS_STARTING=uint64(2**27),
     # DIFFICULTY_STARTING is the starting difficulty for the first epoch, which is then further
     # multiplied by another factor of DIFFICULTY_CONSTANT_FACTOR, to be used in the VDF iter calculation formula.
@@ -26,9 +26,16 @@ DEFAULT_CONSTANTS = ConsensusConstants(
     EPOCH_BLOCKS=uint32(4608),  # The number of blocks per epoch, mainnet 4608. Must be multiple of SUB_EPOCH_SB
     SIGNIFICANT_BITS=uint8(8),  # The number of bits to look at in difficulty and min iters. The rest are zeroed
     DISCRIMINANT_SIZE_BITS=uint16(1024),  # Max is 1024 (based on ClassGroupElement int size)
-    NUMBER_ZERO_BITS_PLOT_FILTER=uint8(9),  # H(plot signature of the challenge) must start with these many zeroes
-    MIN_PLOT_SIZE=uint8(32),  # 32 for mainnet
-    MAX_PLOT_SIZE=uint8(50),
+    NUMBER_ZERO_BITS_PLOT_FILTER_V1=uint8(
+        9
+    ),  # H(plot signature of the challenge) must start with these many zeroes, for v1 plots
+    NUMBER_ZERO_BITS_PLOT_FILTER_V2=uint8(
+        5
+    ),  # H(plot signature of the challenge) must start with these many zeroes. for v2 plots
+    MIN_PLOT_SIZE_V1=uint8(32),  # 32 for mainnet
+    MAX_PLOT_SIZE_V1=uint8(50),
+    MIN_PLOT_SIZE_V2=uint8(28),
+    MAX_PLOT_SIZE_V2=uint8(32),
     SUB_SLOT_TIME_TARGET=uint16(600),  # The target number of seconds per slot, mainnet 600
     NUM_SP_INTERVALS_EXTRA=uint8(3),  # The number of sp intervals to add to the signage point
     MAX_FUTURE_TIME2=uint32(2 * 60),  # The next block can have a timestamp of at most these many seconds in the future
@@ -38,7 +45,7 @@ DEFAULT_CONSTANTS = ConsensusConstants(
     # Default used for tests is std_hash(b'')
     GENESIS_CHALLENGE=bytes32.fromhex("e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"),
     # Forks of chia should change the AGG_SIG_*_ADDITIONAL_DATA values to provide
-    # replay attack protection. This is set to mainnet genesis challange
+    # replay attack protection. This is set to mainnet genesis challenge
     AGG_SIG_ME_ADDITIONAL_DATA=AGG_SIG_DATA,
     AGG_SIG_PARENT_ADDITIONAL_DATA=std_hash(AGG_SIG_DATA + bytes([43])),
     AGG_SIG_PUZZLE_ADDITIONAL_DATA=std_hash(AGG_SIG_DATA + bytes([44])),
@@ -72,19 +79,35 @@ DEFAULT_CONSTANTS = ConsensusConstants(
     MAX_GENERATOR_SIZE=uint32(1000000),
     MAX_GENERATOR_REF_LIST_SIZE=uint32(512),  # Number of references allowed in the block generator ref list
     POOL_SUB_SLOT_ITERS=uint64(37600000000),  # iters limit * NUM_SPS
-    SOFT_FORK6_HEIGHT=uint32(6800000),
     # June 2024
     HARD_FORK_HEIGHT=uint32(5496000),
+    HARD_FORK2_HEIGHT=uint32(0xFFFFFFFA),
+    # starting at the hard fork 2 height, v1 plots will gradually be phased out,
+    # and stop working entirely after this many blocks
+    PLOT_V1_PHASE_OUT=uint32(1179648),
     # June 2027
     PLOT_FILTER_128_HEIGHT=uint32(10542000),
     # June 2030
     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),
 )
 
 
 def update_testnet_overrides(network_id: str, overrides: dict[str, Any]) -> None:
-    if network_id == "testnet11":
-        if "SOFT_FORK6_HEIGHT" not in overrides:
-            overrides["SOFT_FORK6_HEIGHT"] = 2000000
+    # These constants changed names to support v2 plots
+    if "MIN_PLOT_SIZE_V1" not in overrides and "MIN_PLOT_SIZE" in overrides:
+        overrides["MIN_PLOT_SIZE_V1"] = overrides["MIN_PLOT_SIZE"]
+        overrides.pop("MIN_PLOT_SIZE")
+    if "MAX_PLOT_SIZE_V1" not in overrides and "MAX_PLOT_SIZE" in overrides:
+        overrides["MAX_PLOT_SIZE_V1"] = overrides["MAX_PLOT_SIZE"]
+        overrides.pop("MAX_PLOT_SIZE")
+    if network_id in {"testnet11", "testneta"}:
+        if "MIN_PLOT_SIZE_V2" not in overrides:
+            overrides["MIN_PLOT_SIZE_V2"] = 18

chia/consensus/deficit.py

@@ -2,11 +2,9 @@ from __future__ import annotations
 
 from typing import Optional
 
-from chia_rs import ConsensusConstants
+from chia_rs import BlockRecord, ConsensusConstants
 from chia_rs.sized_ints import uint8, uint32
 
-from chia.consensus.block_record import BlockRecord
-
 
 def calculate_deficit(
     constants: ConsensusConstants,

chia/consensus/difficulty_adjustment.py

@@ -2,11 +2,10 @@ from __future__ import annotations
 
 from typing import Optional
 
-from chia_rs import ConsensusConstants
+from chia_rs import BlockRecord, ConsensusConstants
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint32, uint64, uint128
 
-from chia.consensus.block_record import BlockRecord
 from chia.consensus.blockchain_interface import BlockRecordsProtocol
 from chia.util.significant_bits import count_significant_bits, truncate_to_significant_bits
 

chia/consensus/find_fork_point.py

@@ -2,13 +2,11 @@ from __future__ import annotations
 
 from typing import Union
 
-from chia_rs import ConsensusConstants
+from chia_rs import BlockRecord, ConsensusConstants, HeaderBlock
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32
 
-from chia.consensus.block_record import BlockRecord
 from chia.consensus.blockchain_interface import BlockRecordsProtocol
-from chia.types.header_block import HeaderBlock
 
 
 async def find_fork_point_in_chain(

chia/consensus/full_block_to_block_record.py

@@ -2,21 +2,16 @@ from __future__ import annotations
 
 from typing import Optional, Union
 
-from chia_rs import ConsensusConstants
+from chia_rs import BlockRecord, ChallengeBlockInfo, ConsensusConstants, FullBlock, HeaderBlock, SubEpochSummary
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint32, uint64
 
-from chia.consensus.block_record import BlockRecord
 from chia.consensus.blockchain_interface import BlockRecordsProtocol
 from chia.consensus.deficit import calculate_deficit
 from chia.consensus.difficulty_adjustment import get_next_sub_slot_iters_and_difficulty
 from chia.consensus.make_sub_epoch_summary import make_sub_epoch_summary
 from chia.consensus.pot_iterations import is_overflow_block
 from chia.types.blockchain_format.classgroup import ClassgroupElement
-from chia.types.blockchain_format.slots import ChallengeBlockInfo
-from chia.types.blockchain_format.sub_epoch_summary import SubEpochSummary
-from chia.types.full_block import FullBlock
-from chia.types.header_block import HeaderBlock
 from chia.util.errors import Err
 
 

chia/{util → consensus}/generator_tools.py

@@ -3,14 +3,12 @@ from __future__ import annotations
 from collections.abc import Collection
 from typing import Optional
 
+from chia_rs import FullBlock, HeaderBlock, SpendBundleConditions
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint64
 from chiabip158 import PyBIP158
 
 from chia.types.blockchain_format.coin import Coin
-from chia.types.full_block import FullBlock
-from chia.types.header_block import HeaderBlock
-from chia.types.spend_bundle_conditions import SpendBundleConditions
 
 
 def get_block_header(

chia/consensus/get_block_challenge.py

@@ -1,17 +1,13 @@
 from __future__ import annotations
 
 import logging
-from typing import Union
+from typing import Optional, Union
 
-from chia_rs import ConsensusConstants
+from chia_rs import BlockRecord, ConsensusConstants, FullBlock, HeaderBlock, UnfinishedBlock
 from chia_rs.sized_bytes import bytes32
-from chia_rs.sized_ints import uint64
+from chia_rs.sized_ints import uint32, uint64
 
-from chia.consensus.block_record import BlockRecord
 from chia.consensus.blockchain_interface import BlockRecordsProtocol
-from chia.types.full_block import FullBlock
-from chia.types.header_block import HeaderBlock
-from chia.types.unfinished_block import UnfinishedBlock
 from chia.types.unfinished_header_block import UnfinishedHeaderBlock
 
 log = logging.getLogger(__name__)
@@ -105,3 +101,30 @@ def get_block_challenge(
                 curr = blocks.block_record(curr.prev_hash)
             challenge = reversed_challenge_hashes[challenges_to_look_for - 1]
     return challenge
+
+
+def prev_tx_block(
+    blocks: BlockRecordsProtocol,
+    prev_b: Optional[Union[BlockRecord, FullBlock, HeaderBlock]],
+) -> uint32:
+    # todo add check to make sure we dont return tx block from same sp as block we are validating
+    if prev_b is None:
+        return uint32(0)
+    if isinstance(prev_b, BlockRecord):
+        if prev_b.prev_transaction_block_hash is not None:
+            return prev_b.height
+        else:
+            curr = prev_b
+    elif isinstance(prev_b, FullBlock):
+        if prev_b.foliage_transaction_block is not None:
+            return prev_b.height
+        else:
+            curr = blocks.block_record(prev_b.header_hash)
+    elif isinstance(prev_b, HeaderBlock):
+        if prev_b.foliage_transaction_block is not None:
+            return prev_b.height
+        else:
+            curr = blocks.block_record(prev_b.header_hash)
+    while curr.is_transaction_block is False and curr.height > 0:
+        curr = blocks.block_record(curr.prev_hash)
+    return curr.height