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

chia/_tests/pools/test_pool_wallet.py

@@ -11,6 +11,7 @@ from chia_rs.sized_bytes import bytes32
 
 from chia._tests.util.benchmarks import rand_g1, rand_hash
 from chia.pools.pool_wallet import PoolWallet
+from chia.wallet.wallet_action_scope import WalletActionScope
 
 
 @dataclass
@@ -54,6 +55,14 @@ class MockPoolWalletInfo:
     current: MockPoolState
 
 
+@dataclass
+class MockActionScope:
+    payout_instructions_ph: bytes32
+
+    async def get_puzzle_hash(self, wallet_state_manager: Any) -> bytes32:
+        return self.payout_instructions_ph
+
+
 @pytest.mark.anyio
 async def test_update_pool_config_new_config(monkeypatch: Any) -> None:
     """
@@ -108,7 +117,7 @@ async def test_update_pool_config_new_config(monkeypatch: Any) -> None:
         wallet_id=MagicMock(),
     )
 
-    await wallet.update_pool_config()
+    await wallet.update_pool_config(cast(WalletActionScope, MockActionScope(payout_instructions_ph)))
 
     assert len(updated_configs) == 1
     assert updated_configs[0].launcher_id == launcher_id
@@ -191,7 +200,7 @@ async def test_update_pool_config_existing_payout_instructions(monkeypatch: Any)
         wallet_id=MagicMock(),
     )
 
-    await wallet.update_pool_config()
+    await wallet.update_pool_config(MagicMock())
 
     assert len(updated_configs) == 1
     assert updated_configs[0].launcher_id == launcher_id

chia/_tests/pools/test_wallet_pool_store.py

@@ -5,6 +5,7 @@ from dataclasses import dataclass, field
 from typing import Optional
 
 import pytest
+from chia_rs import CoinSpend
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64
 from clvm_tools import binutils
@@ -12,8 +13,8 @@ from clvm_tools import binutils
 from chia._tests.util.db_connection import DBConnection
 from chia.types.blockchain_format.coin import Coin
 from chia.types.blockchain_format.program import Program
-from chia.types.blockchain_format.serialized_program import SerializedProgram
-from chia.types.coin_spend import CoinSpend, compute_additions, make_spend
+from chia.types.coin_spend import make_spend
+from chia.wallet.util.compute_additions import compute_additions
 from chia.wallet.wallet_pool_store import WalletPoolStore
 
 
@@ -30,8 +31,8 @@ def make_child_solution(
         new_coin = compute_additions(coin_spend)[0]
     sol: CoinSpend = make_spend(
         new_coin,
-        SerializedProgram.from_program(puzzle_prog),
-        SerializedProgram.from_program(solution_prog),
+        puzzle_prog,
+        solution_prog,
     )
     return sol
 

chia/_tests/rpc/test_rpc_client.py

@@ -9,9 +9,9 @@ import pytest
 from chia_rs.sized_ints import uint16
 
 from chia._tests.util.misc import Marks, RecordingWebServer, datacases
+from chia.protocols.outbound_message import NodeType
 from chia.rpc.rpc_client import ResponseFailureError, RpcClient
 from chia.rpc.rpc_server import RpcServer
-from chia.server.outbound_message import NodeType
 
 non_fetch_client_methods = {
     RpcClient.create,

chia/_tests/simulation/test_simulation.py

@@ -10,6 +10,7 @@ import dns.rdatatype
 import dns.rdtypes.IN.A
 import dns.rdtypes.IN.AAAA
 import pytest
+from chia_rs import BlockRecord
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint16, uint32, uint64
 
@@ -17,12 +18,11 @@ from chia._tests.core.node_height import node_height_at_least
 from chia._tests.util.setup_nodes import FullSystem, OldSimulatorsAndWallets
 from chia._tests.util.time_out_assert import time_out_assert
 from chia.cmds.units import units
-from chia.consensus.block_record import BlockRecord
 from chia.consensus.block_rewards import calculate_base_farmer_reward, calculate_pool_reward
 from chia.daemon.server import WebSocketServer
 from chia.full_node.full_node import FullNode
 from chia.full_node.full_node_api import FullNodeAPI
-from chia.server.outbound_message import NodeType
+from chia.protocols.outbound_message import NodeType
 from chia.server.server import ChiaServer
 from chia.simulator.block_tools import BlockTools, create_block_tools_async, test_constants
 from chia.simulator.full_node_simulator import FullNodeSimulator
@@ -43,10 +43,11 @@ test_constants_modified = test_constants.replace(
     WEIGHT_PROOF_THRESHOLD=uint8(2),
     WEIGHT_PROOF_RECENT_BLOCKS=uint32(350),
     MAX_SUB_SLOT_BLOCKS=uint32(50),
-    NUM_SPS_SUB_SLOT=uint32(32),  # Must be a power of 2
+    NUM_SPS_SUB_SLOT=uint8(32),  # Must be a power of 2
     EPOCH_BLOCKS=uint32(280),
     SUB_SLOT_ITERS_STARTING=uint64(2**20),
-    NUMBER_ZERO_BITS_PLOT_FILTER=uint8(5),
+    NUMBER_ZERO_BITS_PLOT_FILTER_V1=uint8(5),
+    NUMBER_ZERO_BITS_PLOT_FILTER_V2=uint8(5),
 )
 
 
@@ -211,7 +212,9 @@ class TestSimulation:
         wallet_node, server_2 = wallets[0]
         wallet_node_2, _server_3 = wallets[1]
         wallet = wallet_node.wallet_state_manager.main_wallet
-        ph = await wallet.get_new_puzzlehash()
+        wallet_2 = wallet_node_2.wallet_state_manager.main_wallet
+        async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+            ph = await action_scope.get_puzzle_hash(wallet.wallet_state_manager)
         wallet_node.config["trusted_peers"] = {}
         wallet_node_2.config["trusted_peers"] = {}
 
@@ -227,10 +230,12 @@ class TestSimulation:
 
         await time_out_assert(10, wallet.get_confirmed_balance, funds)
         await time_out_assert(5, wallet.get_unconfirmed_balance, funds)
+        async with wallet_2.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
+            ph_2 = await action_scope.get_puzzle_hash(wallet_2.wallet_state_manager)
         async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
             await wallet.generate_signed_transaction(
                 [uint64(10)],
-                [await wallet_node_2.wallet_state_manager.main_wallet.get_new_puzzlehash()],
+                [ph_2],
                 action_scope,
                 uint64(0),
             )
@@ -406,7 +411,7 @@ class TestSimulation:
             async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
                 await wallet.generate_signed_transaction(
                     amounts=[uint64(tx_amount)],
-                    puzzle_hashes=[await wallet_node.wallet_state_manager.main_wallet.get_new_puzzlehash()],
+                    puzzle_hashes=[await action_scope.get_puzzle_hash(wallet.wallet_state_manager)],
                     action_scope=action_scope,
                     coins={coin},
                 )
@@ -455,7 +460,7 @@ class TestSimulation:
                 for coin in coins:
                     await wallet.generate_signed_transaction(
                         amounts=[uint64(tx_amount)],
-                        puzzle_hashes=[await wallet_node.wallet_state_manager.main_wallet.get_new_puzzlehash()],
+                        puzzle_hashes=[await action_scope.get_puzzle_hash(wallet.wallet_state_manager)],
                         action_scope=action_scope,
                         coins={coin},
                     )

chia/_tests/simulation/test_simulator.py

@@ -128,7 +128,7 @@ async def test_wait_transaction_records_entered_mempool(
         async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
             await wallet.generate_signed_transaction(
                 amounts=[uint64(tx_amount)],
-                puzzle_hashes=[await wallet_node.wallet_state_manager.main_wallet.get_new_puzzlehash()],
+                puzzle_hashes=[await action_scope.get_puzzle_hash(wallet.wallet_state_manager)],
                 action_scope=action_scope,
                 coins={coin},
             )
@@ -164,7 +164,7 @@ async def test_process_transaction_records(
         async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
             await wallet.generate_signed_transaction(
                 amounts=[uint64(tx_amount)],
-                puzzle_hashes=[await wallet_node.wallet_state_manager.main_wallet.get_new_puzzlehash()],
+                puzzle_hashes=[await action_scope.get_puzzle_hash(wallet.wallet_state_manager)],
                 action_scope=action_scope,
                 coins={coin},
             )

chia/_tests/timelord/test_new_peak.py

@@ -3,65 +3,94 @@ from __future__ import annotations
 from typing import Optional
 
 import pytest
+from chia_rs import BlockRecord, FullBlock, SubEpochSummary, UnfinishedBlock
 from chia_rs.sized_bytes import bytes32
-from chia_rs.sized_ints import uint128
+from chia_rs.sized_ints import uint64, uint128
 
 from chia._tests.blockchain.blockchain_test_utils import _validate_and_add_block
 from chia._tests.util.blockchain import create_blockchain
 from chia._tests.util.time_out_assert import time_out_assert
-from chia.consensus.block_record import BlockRecord
 from chia.consensus.blockchain import Blockchain
 from chia.consensus.difficulty_adjustment import get_next_sub_slot_iters_and_difficulty
 from chia.consensus.make_sub_epoch_summary import next_sub_epoch_summary
 from chia.protocols import timelord_protocol
+from chia.server.aliases import FullNodeService
 from chia.server.server import ChiaServer
 from chia.simulator.block_tools import BlockTools
 from chia.simulator.full_node_simulator import FullNodeSimulator
+from chia.simulator.wallet_tools import WalletTool
 from chia.timelord.timelord_api import TimelordAPI
-from chia.types.aliases import FullNodeService
-from chia.types.blockchain_format.sub_epoch_summary import SubEpochSummary
-from chia.types.full_block import FullBlock
-from chia.types.unfinished_block import UnfinishedBlock
 
 
 class TestNewPeak:
     @pytest.mark.anyio
     async def test_timelord_new_peak_basic(
-        self, bt: BlockTools, timelord: tuple[TimelordAPI, ChiaServer], default_1000_blocks: list[FullBlock]
+        self,
+        timelord: tuple[TimelordAPI, ChiaServer],
+        default_1000_blocks: list[FullBlock],
+        one_node: tuple[list[FullNodeService], list[FullNodeSimulator], BlockTools],
     ) -> None:
+        [full_node_service], _, bt = one_node
+        full_node = full_node_service._node
         async with create_blockchain(bt.constants, 2) as (b1, _):
             async with create_blockchain(bt.constants, 2) as (b2, _):
                 timelord_api, _ = timelord
                 for block in default_1000_blocks:
                     await _validate_and_add_block(b1, block)
                     await _validate_and_add_block(b2, block)
+                    await full_node.add_block(block)
 
                 peak = timelord_peak_from_block(b1, default_1000_blocks[-1])
                 assert peak is not None
                 assert timelord_api.timelord.new_peak is None
                 await timelord_api.new_peak_timelord(peak)
-                assert timelord_api.timelord.new_peak is not None
-                assert timelord_api.timelord.new_peak.reward_chain_block.height == peak.reward_chain_block.height
+                await time_out_assert(60, tl_new_peak_is_none, True, timelord_api)
+                assert timelord_api.timelord.last_state.peak is not None
+                assert (
+                    timelord_api.timelord.last_state.peak.reward_chain_block.get_hash()
+                    == peak.reward_chain_block.get_hash()
+                )
                 blocks = bt.get_consecutive_blocks(1, default_1000_blocks)
                 await _validate_and_add_block(b1, blocks[-1])
                 await _validate_and_add_block(b2, blocks[-1])
 
                 await timelord_api.new_peak_timelord(timelord_peak_from_block(b1, blocks[-1]))
-                assert timelord_api.timelord.new_peak.reward_chain_block.height == blocks[-1].height
+                await full_node.add_block(blocks[-1])
+                await time_out_assert(60, tl_new_peak_is_none, True, timelord_api)
+                assert timelord_api.timelord.last_state.peak is not None
+                assert (
+                    timelord_api.timelord.last_state.peak.reward_chain_block.get_hash()
+                    == blocks[-1].reward_chain_block.get_hash()
+                )
+                fn_peak = full_node.blockchain.get_peak()
+                assert fn_peak is not None and fn_peak.header_hash == blocks[-1].header_hash
 
                 blocks_1 = bt.get_consecutive_blocks(2, blocks)
                 await _validate_and_add_block(b1, blocks_1[-2])
                 await _validate_and_add_block(b1, blocks_1[-1])
                 await timelord_api.new_peak_timelord(timelord_peak_from_block(b1, blocks_1[-2]))
+                await full_node.add_block(blocks_1[-2])
                 await timelord_api.new_peak_timelord(timelord_peak_from_block(b1, blocks_1[-1]))
-                assert timelord_api.timelord.new_peak.reward_chain_block.height == blocks_1[-1].height
+                await full_node.add_block(blocks_1[-1])
+                await time_out_assert(60, tl_new_peak_is_none, True, timelord_api)
+                assert timelord_api.timelord.last_state.peak is not None
+                assert (
+                    timelord_api.timelord.last_state.peak.reward_chain_block.get_hash()
+                    == blocks_1[-1].reward_chain_block.get_hash()
+                )
+                fn_peak = full_node.blockchain.get_peak()
+                assert fn_peak is not None and fn_peak.header_hash == blocks_1[-1].header_hash
 
                 # new unknown peak, weight less then curr peak
                 blocks_2 = bt.get_consecutive_blocks(1, blocks)
                 await _validate_and_add_block(b2, blocks_2[-1])
                 await timelord_api.new_peak_timelord(timelord_peak_from_block(b2, blocks_2[-1]))
+                await full_node.add_block(blocks_2[-1])
+                await time_out_assert(60, tl_new_peak_is_none, True, timelord_api)
                 assert timelord_api.timelord.last_state.last_weight == blocks_1[-1].weight
                 assert timelord_api.timelord.last_state.total_iters == blocks_1[-1].reward_chain_block.total_iters
+                fn_peak = full_node.blockchain.get_peak()
+                assert fn_peak is not None and fn_peak.header_hash == blocks_1[-1].header_hash
 
     @pytest.mark.anyio
     async def test_timelord_new_peak_unfinished_not_orphaned(
@@ -87,14 +116,11 @@ class TestNewPeak:
             await _validate_and_add_block(b1, block_2)
 
             block_record = b1.block_record(block_2.header_hash)
-            sub_slot_iters, difficulty = get_next_sub_slot_iters_and_difficulty(
-                bt.constants, len(block_1.finished_sub_slots) > 0, b1.block_record(block_1.prev_header_hash), b1
-            )
 
             timelord_unf_block = timelord_protocol.NewUnfinishedBlockTimelord(
                 block_1.reward_chain_block.get_unfinished(),
-                difficulty,
-                sub_slot_iters,
+                uint64(block_record.weight - default_1000_blocks[-1].weight),
+                block_record.sub_slot_iters,
                 block_1.foliage,
                 next_sub_epoch_summary(bt.constants, b1, block_record.required_iters, block_1, True),
                 await get_rc_prev(b1, block_1),
@@ -106,7 +132,7 @@ class TestNewPeak:
             assert timelord_unf_block.reward_chain_block.total_iters <= new_peak.reward_chain_block.total_iters
             await timelord_api.new_peak_timelord(new_peak)
 
-            await time_out_assert(60, peak_new_peak_is_none, True, timelord_api)
+            await time_out_assert(60, tl_new_peak_is_none, True, timelord_api)
 
             assert (
                 timelord_api.timelord.last_state.peak.reward_chain_block.get_hash()
@@ -135,8 +161,11 @@ class TestNewPeak:
                 assert timelord_api.timelord.new_peak is None
                 await timelord_api.new_peak_timelord(peak)
                 assert timelord_api.timelord.new_peak is not None
+                await time_out_assert(60, tl_new_peak_is_none, True, timelord_api)
+                assert timelord_api.timelord.last_state.peak is not None
                 assert (
-                    timelord_api.timelord.new_peak.reward_chain_block.get_hash() == peak.reward_chain_block.get_hash()
+                    timelord_api.timelord.last_state.peak.reward_chain_block.get_hash()
+                    == peak.reward_chain_block.get_hash()
                 )
 
                 # make two new blocks on tip, block_2 has higher total iterations
@@ -154,17 +183,11 @@ class TestNewPeak:
                 await _validate_and_add_block(b2, block_2)
 
                 block_record_1 = b1.block_record(block_1.header_hash)
-                sub_slot_iters, difficulty = get_next_sub_slot_iters_and_difficulty(
-                    bt.constants,
-                    len(block_1.finished_sub_slots) > 0,
-                    b1.block_record(block_1.prev_header_hash),
-                    b1,
-                )
 
                 timelord_unf_block = timelord_protocol.NewUnfinishedBlockTimelord(
                     block_1.reward_chain_block.get_unfinished(),
-                    difficulty,
-                    sub_slot_iters,
+                    uint64(block_record_1.weight - default_1000_blocks[-1].weight),
+                    block_record_1.sub_slot_iters,
                     block_1.foliage,
                     next_sub_epoch_summary(bt.constants, b1, block_record_1.required_iters, block_1, True),
                     await get_rc_prev(b1, block_1),
@@ -177,7 +200,7 @@ class TestNewPeak:
                 # add block_2 peak and make sure we skip it and prefer to finish block_1
                 assert timelord_unf_block.reward_chain_block.total_iters <= new_peak.reward_chain_block.total_iters
                 await timelord_api.new_peak_timelord(new_peak)
-                await time_out_assert(60, peak_new_peak_is_none, True, timelord_api)
+                await time_out_assert(60, tl_new_peak_is_none, True, timelord_api)
 
                 # check that peak did not change
                 assert (
@@ -238,15 +261,22 @@ class TestNewPeak:
                 assert peak is not None
                 assert timelord_api.timelord.new_peak is None
                 await timelord_api.new_peak_timelord(peak)
-                assert timelord_api.timelord.new_peak is not None
+                await time_out_assert(60, tl_new_peak_is_none, True, timelord_api)
+                assert timelord_api.timelord.last_state.peak is not None
                 assert (
-                    timelord_api.timelord.new_peak.reward_chain_block.get_hash() == peak.reward_chain_block.get_hash()
+                    timelord_api.timelord.last_state.peak.reward_chain_block.get_hash()
+                    == peak.reward_chain_block.get_hash()
                 )
 
                 # make two new blocks on tip
                 block_1 = bt.get_consecutive_blocks(1, default_1000_blocks, time_per_block=9, force_overflow=True)[-1]
                 block_2 = bt.get_consecutive_blocks(
-                    1, default_1000_blocks, seed=b"data", time_per_block=50, skip_slots=1
+                    1,
+                    default_1000_blocks,
+                    seed=b"data",
+                    time_per_block=50,
+                    skip_slots=1,
+                    min_signage_point=block_1.reward_chain_block.signage_point_index,
                 )[-1]
                 # make sure block_2 has higher iterations
                 assert block_2.total_iters >= block_1.total_iters
@@ -275,9 +305,10 @@ class TestNewPeak:
                 assert timelord_api.timelord.overflow_blocks[-1].get_hash() == timelord_unf_block.get_hash()
                 new_peak = timelord_peak_from_block(b2, block_2)
                 assert timelord_unf_block.reward_chain_block.total_iters <= new_peak.reward_chain_block.total_iters
+                assert block_1.reward_chain_block.get_hash() != new_peak.reward_chain_block.get_hash()
                 await timelord_api.new_peak_timelord(new_peak)
 
-                await time_out_assert(60, peak_new_peak_is_none, True, timelord_api)
+                await time_out_assert(60, tl_new_peak_is_none, True, timelord_api)
 
                 assert (
                     timelord_api.timelord.last_state.peak.reward_chain_block.get_hash()
@@ -286,22 +317,30 @@ class TestNewPeak:
 
     @pytest.mark.anyio
     async def test_timelord_new_peak_unfinished_eos(
-        self, bt: BlockTools, timelord: tuple[TimelordAPI, ChiaServer], default_1000_blocks: list[FullBlock]
+        self,
+        one_node: tuple[list[FullNodeService], list[FullNodeSimulator], BlockTools],
+        timelord: tuple[TimelordAPI, ChiaServer],
+        default_1000_blocks: list[FullBlock],
     ) -> None:
+        [full_node_service], _, bt = one_node
+        full_node = full_node_service._node
         async with create_blockchain(bt.constants, 2) as (b1, _):
             async with create_blockchain(bt.constants, 2) as (b2, _):
                 timelord_api, _ = timelord
                 for block in default_1000_blocks:
                     await _validate_and_add_block(b1, block)
                     await _validate_and_add_block(b2, block)
+                    await full_node.add_block(block)
 
                 peak = timelord_peak_from_block(b1, default_1000_blocks[-1])
                 assert peak is not None
                 assert timelord_api.timelord.new_peak is None
                 await timelord_api.new_peak_timelord(peak)
-                assert timelord_api.timelord.new_peak is not None
+                await time_out_assert(60, tl_new_peak_is_none, True, timelord_api)
+                assert timelord_api.timelord.last_state.peak is not None
                 assert (
-                    timelord_api.timelord.new_peak.reward_chain_block.get_hash() == peak.reward_chain_block.get_hash()
+                    timelord_api.timelord.last_state.peak.reward_chain_block.get_hash()
+                    == peak.reward_chain_block.get_hash()
                 )
 
                 # make two new blocks on tip, block_2 is in a new slot
@@ -315,19 +354,15 @@ class TestNewPeak:
 
                 await _validate_and_add_block(b1, block_1)
                 await _validate_and_add_block(b2, block_2)
+                await full_node.add_block(block_2)
+                fn_peak = full_node.blockchain.get_peak()
+                assert fn_peak is not None and fn_peak.header_hash == block_2.header_hash
 
                 block_record = b2.block_record(block_2.header_hash)
-                sub_slot_iters, difficulty = get_next_sub_slot_iters_and_difficulty(
-                    bt.constants,
-                    len(block_2.finished_sub_slots) > 0,
-                    b1.block_record(block_2.prev_header_hash),
-                    b1,
-                )
-
                 timelord_unf_block = timelord_protocol.NewUnfinishedBlockTimelord(
                     block_2.reward_chain_block.get_unfinished(),
-                    difficulty,
-                    sub_slot_iters,
+                    uint64(block_record.weight - default_1000_blocks[-1].weight),
+                    block_record.sub_slot_iters,
                     block_2.foliage,
                     next_sub_epoch_summary(bt.constants, b1, block_record.required_iters, block_2, True),
                     await get_rc_prev(b2, block_2),
@@ -340,7 +375,8 @@ class TestNewPeak:
                 new_peak = timelord_peak_from_block(b1, block_1)
                 assert timelord_unf_block.reward_chain_block.total_iters >= new_peak.reward_chain_block.total_iters
                 await timelord_api.new_peak_timelord(new_peak)
-                await time_out_assert(60, peak_new_peak_is_none, True, timelord_api)
+                await full_node.add_block(block_1)
+                await time_out_assert(60, tl_new_peak_is_none, True, timelord_api)
 
                 # make sure we switch to lower iteration peak
                 assert (
@@ -348,6 +384,9 @@ class TestNewPeak:
                     == new_peak.reward_chain_block.get_hash()
                 )
 
+                fn_peak = full_node.blockchain.get_peak()
+                assert fn_peak is not None and fn_peak.header_hash == block_1.header_hash
+
     @pytest.mark.anyio
     async def test_timelord_new_peak_node_sync(
         self,
@@ -373,7 +412,7 @@ class TestNewPeak:
                 assert (
                     timelord_api.timelord.new_peak.reward_chain_block.get_hash() == peak.reward_chain_block.get_hash()
                 )
-                await time_out_assert(60, peak_new_peak_is_none, True, timelord_api)
+                await time_out_assert(60, tl_new_peak_is_none, True, timelord_api)
                 # make two new blocks on tip, block_2 has higher total iterations
                 block_1 = bt.get_consecutive_blocks(1, default_1000_blocks)[-1]
                 block_2 = bt.get_consecutive_blocks(
@@ -394,7 +433,7 @@ class TestNewPeak:
                 assert timelord_api.timelord.new_peak is not None
                 assert peak.header_hash == block_2.header_hash
                 assert peak_tl.reward_chain_block.get_hash() == peak.reward_chain_block.get_hash()
-                await time_out_assert(60, peak_new_peak_is_none, True, timelord_api)
+                await time_out_assert(60, tl_new_peak_is_none, True, timelord_api)
 
                 await full_node.add_block(block_1)
                 await _validate_and_add_block(b1, block_1)
@@ -406,6 +445,111 @@ class TestNewPeak:
                 peak_tl = timelord_api.timelord.new_peak
                 assert peak_tl.reward_chain_block.get_hash() == peak.reward_chain_block.get_hash()
 
+    @pytest.mark.anyio
+    @pytest.mark.parametrize("different_foliage", [False, True])
+    async def test_timelord_new_peak_is_in_unfinished_cache(
+        self,
+        one_node: tuple[list[FullNodeService], list[FullNodeSimulator], BlockTools],
+        timelord: tuple[TimelordAPI, ChiaServer],
+        default_1000_blocks: list[FullBlock],
+        different_foliage: bool,
+    ) -> None:
+        _, _, bt = one_node
+        wallet = WalletTool(bt.constants)
+        coinbase_puzzlehash = wallet.get_new_puzzlehash()
+        timelord_api, _ = timelord
+        blocks = bt.get_consecutive_blocks(
+            num_blocks=10,
+            block_list_input=default_1000_blocks,
+            skip_overflow=True,
+            force_overflow=False,
+            farmer_reward_puzzle_hash=coinbase_puzzlehash,
+            guarantee_transaction_block=True,
+        )
+        async with create_blockchain(bt.constants, 2) as (b1, _):
+            for block in blocks:
+                await _validate_and_add_block(b1, block)
+
+            peak = timelord_peak_from_block(b1, blocks[-1])
+            assert peak is not None and timelord_api.timelord.new_peak is None
+            await timelord_api.new_peak_timelord(peak)
+            assert timelord_api.timelord.new_peak is not None
+            await time_out_assert(60, tl_new_peak_is_none, True, timelord_api)
+            assert (
+                timelord_api.timelord.last_state.peak is not None
+                and timelord_api.timelord.last_state.peak.reward_chain_block.get_hash()
+                == peak.reward_chain_block.get_hash()
+            )
+
+            block_1 = bt.get_consecutive_blocks(
+                block_list_input=blocks,
+                num_blocks=1,
+                farmer_reward_puzzle_hash=coinbase_puzzlehash,
+                guarantee_transaction_block=True,
+                skip_overflow=True,
+            )[-1]
+
+            await _validate_and_add_block(b1, block_1)
+            block_record_1 = b1.block_record(block_1.header_hash)
+            if len(block_1.finished_sub_slots) > 0:
+                timelord_api.timelord.last_state.set_state(block_1.finished_sub_slots[-1])
+
+            block_1_diffrent_foliage = None
+            if not different_foliage:
+                timelord_unf_block = timelord_protocol.NewUnfinishedBlockTimelord(
+                    block_1.reward_chain_block.get_unfinished(),
+                    uint64(block_record_1.weight - blocks[-1].weight),
+                    block_record_1.sub_slot_iters,
+                    block_1.foliage,
+                    next_sub_epoch_summary(bt.constants, b1, block_record_1.required_iters, block_1, True),
+                    await get_rc_prev(b1, block_1),
+                )
+            else:
+                spend_coin = None
+                for coin in blocks[-8].get_included_reward_coins():
+                    if coin.puzzle_hash == coinbase_puzzlehash:
+                        spend_coin = coin
+
+                assert spend_coin is not None
+                sb = wallet.generate_signed_transaction(uint64(1000), bytes32(b"0" * 32), spend_coin)
+                block_1_diffrent_foliage = bt.get_consecutive_blocks(
+                    block_list_input=blocks,
+                    num_blocks=1,
+                    farmer_reward_puzzle_hash=coinbase_puzzlehash,
+                    guarantee_transaction_block=True,
+                    transaction_data=sb,
+                    skip_overflow=True,
+                )[-1]
+                assert block_1_diffrent_foliage.header_hash != block_1.header_hash
+                timelord_unf_block = timelord_protocol.NewUnfinishedBlockTimelord(
+                    block_1_diffrent_foliage.reward_chain_block.get_unfinished(),
+                    uint64(block_1_diffrent_foliage.weight - blocks[-1].weight),
+                    block_record_1.sub_slot_iters,
+                    block_1_diffrent_foliage.foliage,
+                    next_sub_epoch_summary(bt.constants, b1, block_record_1.required_iters, block_1, True),
+                    await get_rc_prev(b1, block_1),
+                )
+
+            await timelord_api.new_unfinished_block_timelord(timelord_unf_block)
+            assert timelord_api.timelord.unfinished_blocks[-1].get_hash() == timelord_unf_block.get_hash()
+            assert (
+                timelord_api.timelord.unfinished_blocks[-1].reward_chain_block.get_hash()
+                == timelord_unf_block.reward_chain_block.get_hash()
+            )
+
+            new_peak = timelord_peak_from_block(b1, block_1)
+            assert timelord_unf_block.reward_chain_block.total_iters == new_peak.reward_chain_block.total_iters
+            await timelord_api.new_peak_timelord(new_peak)
+            await time_out_assert(60, tl_new_peak_is_none, True, timelord_api)
+
+            # check that peak was not skipped
+            assert (
+                timelord_api.timelord.last_state.peak.reward_chain_block.get_hash()
+                == new_peak.reward_chain_block.get_hash()
+            )
+            # check unfinished block_1 is not in cache
+            assert len(timelord_api.timelord.unfinished_blocks) == 0
+
 
 async def get_rc_prev(blockchain: Blockchain, block: FullBlock) -> bytes32:
     if block.reward_chain_block.signage_point_index == 0:
@@ -491,5 +635,5 @@ def timelord_peak_from_block(
     )
 
 
-def peak_new_peak_is_none(timelord: TimelordAPI) -> bool:
+def tl_new_peak_is_none(timelord: TimelordAPI) -> bool:
     return timelord.timelord.new_peak is None

chia/_tests/timelord/test_timelord.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import pytest
 
-from chia.types.aliases import TimelordService
+from chia.server.aliases import TimelordService
 
 
 @pytest.mark.anyio

chia/_tests/tools/test_full_sync.py

@@ -1,5 +1,3 @@
-#!/usr/bin/env python3
-
 from __future__ import annotations
 
 import asyncio

chia/_tests/tools/test_run_block.py

@@ -33,7 +33,9 @@ constants = DEFAULT_CONSTANTS.replace(
         "d23da14695a188ae5708dd152263c4db883eb27edeb936178d4d988b8f3ce5fc"
     ),
     MEMPOOL_BLOCK_BUFFER=uint8(10),
-    MIN_PLOT_SIZE=uint8(18),
+    MIN_PLOT_SIZE_V1=uint8(18),
+    # TODO: todo_v2_plots decide on v2 test plot k-size
+    MIN_PLOT_SIZE_V2=uint8(18),
 )
 retire_bytes = (
     b"\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"

chia/_tests/util/benchmark_cost.py

@@ -115,7 +115,7 @@ if __name__ == "__main__":
     seeded_random = random.Random()
     seeded_random.seed(a=0, version=2)
 
-    for i in range(0, 1000):
+    for i in range(1000):
         private_key: PrivateKey = master_sk_to_wallet_sk(secret_key, uint32(i))
         public_key = private_key.get_g1()
         solution = wallet_tool.make_solution(
@@ -134,7 +134,7 @@ if __name__ == "__main__":
     # Run Puzzle 1000 times
     puzzle_start = time.time()
     clvm_cost = 0
-    for i in range(0, 1000):
+    for i in range(1000):
         cost_run, _ = puzzles[i].run_with_cost(INFINITE_COST, solutions[i])
         clvm_cost += cost_run
 
@@ -152,7 +152,7 @@ if __name__ == "__main__":
     # Run AggSig 1000 times
     agg_sig_start = time.time()
     agg_sig_cost = 0
-    for i in range(0, 1000):
+    for i in range(1000):
         valid = AugSchemeMPL.verify(public_key, message, signature)
         assert valid
         agg_sig_cost += 20