chia-blockchain 2.5.0rc2__py3-none-any.whl → 2.5.1rc2__py3-none-any.whl

chia/_tests/core/full_node/stores/test_block_store.py

@@ -5,7 +5,7 @@ import logging
 import random
 import sqlite3
 from pathlib import Path
-from typing import List, Optional, cast
+from typing import Optional, cast
 
 import pytest
 
@@ -15,7 +15,8 @@ from clvm.casts import int_to_bytes
 
 from chia._tests.blockchain.blockchain_test_utils import _validate_and_add_block
 from chia._tests.util.db_connection import DBConnection, PathDBConnection
-from chia.consensus.blockchain import Blockchain
+from chia.consensus.block_body_validation import ForkInfo
+from chia.consensus.blockchain import AddBlockResult, Blockchain
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
 from chia.consensus.full_block_to_block_record import header_block_to_sub_block_record
 from chia.full_node.block_store import BlockStore
@@ -29,6 +30,7 @@ from chia.types.full_block import FullBlock
 from chia.util.db_wrapper import get_host_parameter_limit
 from chia.util.full_block_utils import GeneratorBlockInfo
 from chia.util.ints import uint8, uint32, uint64
+from chia.util.task_referencer import create_referenced_task
 
 log = logging.getLogger(__name__)
 
@@ -58,9 +60,7 @@ async def test_block_store(tmp_dir: Path, db_version: int, bt: BlockTools, use_c
         time_per_block=10,
     )
     wt: WalletTool = bt.get_pool_wallet_tool()
-    tx = wt.generate_signed_transaction(
-        uint64(10), wt.get_new_puzzlehash(), list(blocks[-1].get_included_reward_coins())[0]
-    )
+    tx = wt.generate_signed_transaction(uint64(10), wt.get_new_puzzlehash(), blocks[-1].get_included_reward_coins()[0])
     blocks = bt.get_consecutive_blocks(
         10,
         block_list_input=blocks,
@@ -135,6 +135,90 @@ async def test_block_store(tmp_dir: Path, db_version: int, bt: BlockTools, use_c
             assert br.header_hash == b.header_hash
 
 
+@pytest.mark.limit_consensus_modes(reason="save time")
+@pytest.mark.anyio
+async def test_get_full_blocks_at(
+    tmp_dir: Path, db_version: int, bt: BlockTools, use_cache: bool, default_400_blocks: list[FullBlock]
+) -> None:
+    blocks = bt.get_consecutive_blocks(10)
+    alt_blocks = default_400_blocks[:10]
+
+    async with DBConnection(2) as db_wrapper:
+        # Use a different file for the blockchain
+        coin_store = await CoinStore.create(db_wrapper)
+        block_store = await BlockStore.create(db_wrapper, use_cache=use_cache)
+        bc = await Blockchain.create(coin_store, block_store, bt.constants, tmp_dir, 2)
+
+        count = 0
+        fork_info = ForkInfo(-1, -1, bt.constants.GENESIS_CHALLENGE)
+        for b1, b2 in zip(blocks, alt_blocks):
+            await _validate_and_add_block(bc, b1)
+            await _validate_and_add_block(bc, b2, expected_result=AddBlockResult.ADDED_AS_ORPHAN, fork_info=fork_info)
+            ret = await block_store.get_full_blocks_at([uint32(count)])
+            assert set(ret) == set([b1, b2])
+            count += 1
+            ret = await block_store.get_full_blocks_at([uint32(c) for c in range(count)])
+            assert len(ret) == count * 2
+            assert set(ret) == set(blocks[:count] + alt_blocks[:count])
+
+
+@pytest.mark.limit_consensus_modes(reason="save time")
+@pytest.mark.anyio
+async def test_get_block_records_in_range(
+    bt: BlockTools, tmp_dir: Path, use_cache: bool, default_400_blocks: list[FullBlock]
+) -> None:
+    blocks = bt.get_consecutive_blocks(10)
+    alt_blocks = default_400_blocks[:10]
+
+    async with DBConnection(2) as db_wrapper:
+        # Use a different file for the blockchain
+        coin_store = await CoinStore.create(db_wrapper)
+        block_store = await BlockStore.create(db_wrapper, use_cache=use_cache)
+        bc = await Blockchain.create(coin_store, block_store, bt.constants, tmp_dir, 2)
+
+        count = 0
+        fork_info = ForkInfo(-1, -1, bt.constants.GENESIS_CHALLENGE)
+        for b1, b2 in zip(blocks, alt_blocks):
+            await _validate_and_add_block(bc, b1)
+            await _validate_and_add_block(bc, b2, expected_result=AddBlockResult.ADDED_AS_ORPHAN, fork_info=fork_info)
+            # the range is inclusive
+            ret = await block_store.get_block_records_in_range(count, count)
+            assert len(ret) == 1
+            assert b1.header_hash in ret
+            ret = await block_store.get_block_records_in_range(0, count)
+            count += 1
+            assert len(ret) == count
+            assert list(ret.keys()) == [b.header_hash for b in blocks[:count]]
+
+
+@pytest.mark.limit_consensus_modes(reason="save time")
+@pytest.mark.anyio
+async def test_get_block_bytes_in_range_in_main_chain(
+    bt: BlockTools, tmp_dir: Path, use_cache: bool, default_400_blocks: list[FullBlock]
+) -> None:
+    blocks = bt.get_consecutive_blocks(10)
+    alt_blocks = default_400_blocks[:10]
+
+    async with DBConnection(2) as db_wrapper:
+        # Use a different file for the blockchain
+        coin_store = await CoinStore.create(db_wrapper)
+        block_store = await BlockStore.create(db_wrapper, use_cache=use_cache)
+        bc = await Blockchain.create(coin_store, block_store, bt.constants, tmp_dir, 2)
+
+        count = 0
+        fork_info = ForkInfo(-1, -1, bt.constants.GENESIS_CHALLENGE)
+        for b1, b2 in zip(blocks, alt_blocks):
+            await _validate_and_add_block(bc, b1)
+            await _validate_and_add_block(bc, b2, expected_result=AddBlockResult.ADDED_AS_ORPHAN, fork_info=fork_info)
+            # the range is inclusive
+            ret = await block_store.get_block_bytes_in_range(count, count)
+            assert ret == [bytes(b1)]
+            ret = await block_store.get_block_bytes_in_range(0, count)
+            count += 1
+            assert len(ret) == count
+            assert set(ret) == set([bytes(b) for b in blocks[:count]])
+
+
 @pytest.mark.limit_consensus_modes(reason="save time")
 @pytest.mark.anyio
 async def test_deadlock(tmp_dir: Path, db_version: int, bt: BlockTools, use_cache: bool) -> None:
@@ -153,25 +237,26 @@ async def test_deadlock(tmp_dir: Path, db_version: int, bt: BlockTools, use_cach
         for block in blocks:
             await _validate_and_add_block(bc, block)
             block_records.append(bc.block_record(block.header_hash))
-        tasks: List[asyncio.Task[object]] = []
+        tasks: list[asyncio.Task[object]] = []
 
         for i in range(10000):
             rand_i = random.randint(0, 9)
             if random.random() < 0.5:
                 tasks.append(
-                    asyncio.create_task(
+                    create_referenced_task(
                         store.add_full_block(blocks[rand_i].header_hash, blocks[rand_i], block_records[rand_i])
                     )
                 )
             if random.random() < 0.5:
-                tasks.append(asyncio.create_task(store.get_full_block(blocks[rand_i].header_hash)))
+                tasks.append(create_referenced_task(store.get_full_block(blocks[rand_i].header_hash)))
         await asyncio.gather(*tasks)
 
 
 @pytest.mark.limit_consensus_modes(reason="save time")
 @pytest.mark.anyio
-async def test_rollback(bt: BlockTools, tmp_dir: Path, use_cache: bool) -> None:
+async def test_rollback(bt: BlockTools, tmp_dir: Path, use_cache: bool, default_400_blocks: list[FullBlock]) -> None:
     blocks = bt.get_consecutive_blocks(10)
+    alt_blocks = default_400_blocks[:10]
 
     async with DBConnection(2) as db_wrapper:
         # Use a different file for the blockchain
@@ -181,8 +266,10 @@ async def test_rollback(bt: BlockTools, tmp_dir: Path, use_cache: bool) -> None:
 
         # insert all blocks
         count = 0
-        for block in blocks:
-            await _validate_and_add_block(bc, block)
+        fork_info = ForkInfo(-1, -1, bt.constants.GENESIS_CHALLENGE)
+        for b1, b2 in zip(blocks, alt_blocks):
+            await _validate_and_add_block(bc, b1)
+            await _validate_and_add_block(bc, b2, expected_result=AddBlockResult.ADDED_AS_ORPHAN, fork_info=fork_info)
             count += 1
             ret = await block_store.get_random_not_compactified(count)
             assert len(ret) == count
@@ -197,6 +284,13 @@ async def test_rollback(bt: BlockTools, tmp_dir: Path, use_cache: bool) -> None:
                     rows = list(await cursor.fetchall())
                     assert len(rows) == 1
                     assert rows[0][0]
+            for block in alt_blocks:
+                async with conn.execute(
+                    "SELECT in_main_chain FROM full_blocks WHERE header_hash=?", (block.header_hash,)
+                ) as cursor:
+                    rows = list(await cursor.fetchall())
+                    assert len(rows) == 1
+                    assert not rows[0][0]
 
         await block_store.rollback(5)
 
@@ -212,6 +306,14 @@ async def test_rollback(bt: BlockTools, tmp_dir: Path, use_cache: bool) -> None:
                     assert len(rows) == 1
                     assert rows[0][0] == (count <= 5)
                 count += 1
+            for block in alt_blocks:
+                async with conn.execute(
+                    "SELECT in_main_chain FROM full_blocks WHERE header_hash=? ORDER BY height",
+                    (block.header_hash,),
+                ) as cursor:
+                    rows = list(await cursor.fetchall())
+                    assert len(rows) == 1
+                    assert not rows[0][0]
 
 
 @pytest.mark.limit_consensus_modes(reason="save time")

chia/_tests/core/full_node/stores/test_coin_store.py

@@ -3,21 +3,22 @@ from __future__ import annotations
 import logging
 from dataclasses import dataclass
 from pathlib import Path
-from typing import List, Optional, Set, Tuple
+from typing import Optional
 
 import pytest
 from clvm.casts import int_to_bytes
 
 from chia._tests.blockchain.blockchain_test_utils import _validate_and_add_block
 from chia._tests.util.db_connection import DBConnection
+from chia._tests.util.get_name_puzzle_conditions import get_name_puzzle_conditions
 from chia._tests.util.misc import Marks, datacases
+from chia.consensus.block_body_validation import ForkInfo
 from chia.consensus.block_rewards import calculate_base_farmer_reward, calculate_pool_reward
 from chia.consensus.blockchain import AddBlockResult, Blockchain
 from chia.consensus.coinbase import create_farmer_coin, create_pool_coin
 from chia.full_node.block_store import BlockStore
 from chia.full_node.coin_store import CoinStore
 from chia.full_node.hint_store import HintStore
-from chia.full_node.mempool_check_conditions import get_name_puzzle_conditions
 from chia.protocols.wallet_protocol import CoinState
 from chia.simulator.block_tools import BlockTools, test_constants
 from chia.simulator.wallet_tools import WalletTool
@@ -38,7 +39,7 @@ WALLET_A = WalletTool(constants)
 log = logging.getLogger(__name__)
 
 
-def get_future_reward_coins(block: FullBlock) -> Tuple[Coin, Coin]:
+def get_future_reward_coins(block: FullBlock) -> tuple[Coin, Coin]:
     pool_amount = calculate_pool_reward(block.height)
     farmer_amount = calculate_base_farmer_reward(block.height)
     if block.is_transaction_block():
@@ -70,7 +71,7 @@ async def test_basic_coin_store(db_version: int, softfork_height: uint32, bt: Bl
         pool_reward_puzzle_hash=reward_ph,
     )
 
-    coins_to_spend: List[Coin] = []
+    coins_to_spend: list[Coin] = []
     for block in blocks:
         if block.is_transaction_block():
             for coin in block.get_included_reward_coins():
@@ -91,14 +92,15 @@ async def test_basic_coin_store(db_version: int, softfork_height: uint32, bt: Bl
         )
 
         # Adding blocks to the coin store
-        should_be_included_prev: Set[Coin] = set()
-        should_be_included: Set[Coin] = set()
+        should_be_included_prev: set[Coin] = set()
+        should_be_included: set[Coin] = set()
         for block in blocks:
             farmer_coin, pool_coin = get_future_reward_coins(block)
             should_be_included.add(farmer_coin)
             should_be_included.add(pool_coin)
             if block.is_transaction_block():
                 if block.transactions_generator is not None:
+                    assert block.transactions_info is not None
                     block_gen: BlockGenerator = BlockGenerator(block.transactions_generator, [])
                     npc_result = get_name_puzzle_conditions(
                         block_gen,
@@ -178,8 +180,8 @@ async def test_set_spent(db_version: int, bt: BlockTools) -> None:
         # Save/get block
         for block in blocks:
             if block.is_transaction_block():
-                removals: List[bytes32] = []
-                additions: List[Coin] = []
+                removals: list[bytes32] = []
+                additions: list[Coin] = []
                 async with db_wrapper.writer():
                     if block.is_transaction_block():
                         assert block.foliage_transaction_block is not None
@@ -229,8 +231,8 @@ async def test_num_unspent(bt: BlockTools, db_version: int) -> None:
 
             if block.is_transaction_block():
                 assert block.foliage_transaction_block is not None
-                removals: List[bytes32] = []
-                additions: List[Coin] = []
+                removals: list[bytes32] = []
+                additions: list[Coin] = []
                 await coin_store.new_block(
                     block.height,
                     block.foliage_transaction_block.timestamp,
@@ -255,13 +257,13 @@ async def test_rollback(db_version: int, bt: BlockTools) -> None:
         coin_store = await CoinStore.create(db_wrapper)
 
         selected_coin: Optional[CoinRecord] = None
-        all_coins: List[Coin] = []
+        all_coins: list[Coin] = []
 
         for block in blocks:
             all_coins += list(block.get_included_reward_coins())
             if block.is_transaction_block():
-                removals: List[bytes32] = []
-                additions: List[Coin] = []
+                removals: list[bytes32] = []
+                additions: list[Coin] = []
                 assert block.foliage_transaction_block is not None
                 await coin_store.new_block(
                     block.height,
@@ -343,7 +345,7 @@ async def test_basic_reorg(tmp_dir: Path, db_version: int, bt: BlockTools) -> No
         store = await BlockStore.create(db_wrapper)
         b: Blockchain = await Blockchain.create(coin_store, store, bt.constants, tmp_dir, 2)
         try:
-            records: List[Optional[CoinRecord]] = []
+            records: list[Optional[CoinRecord]] = []
 
             for block in blocks:
                 await _validate_and_add_block(b, block)
@@ -363,13 +365,20 @@ async def test_basic_reorg(tmp_dir: Path, db_version: int, bt: BlockTools) -> No
 
             blocks_reorg_chain = bt.get_consecutive_blocks(reorg_length, blocks[: initial_block_count - 10], seed=b"2")
 
+            fork_info = ForkInfo(-1, -1, bt.constants.GENESIS_CHALLENGE)
             for reorg_block in blocks_reorg_chain:
                 if reorg_block.height < initial_block_count - 10:
-                    await _validate_and_add_block(b, reorg_block, expected_result=AddBlockResult.ALREADY_HAVE_BLOCK)
+                    await _validate_and_add_block(
+                        b, reorg_block, expected_result=AddBlockResult.ALREADY_HAVE_BLOCK, fork_info=fork_info
+                    )
                 elif reorg_block.height < initial_block_count:
-                    await _validate_and_add_block(b, reorg_block, expected_result=AddBlockResult.ADDED_AS_ORPHAN)
+                    await _validate_and_add_block(
+                        b, reorg_block, expected_result=AddBlockResult.ADDED_AS_ORPHAN, fork_info=fork_info
+                    )
                 elif reorg_block.height >= initial_block_count:
-                    await _validate_and_add_block(b, reorg_block, expected_result=AddBlockResult.NEW_PEAK)
+                    await _validate_and_add_block(
+                        b, reorg_block, expected_result=AddBlockResult.NEW_PEAK, fork_info=fork_info
+                    )
                     if reorg_block.is_transaction_block():
                         coins = reorg_block.get_included_reward_coins()
                         records = [await coin_store.get_coin_record(coin.name()) for coin in coins]
@@ -501,16 +510,16 @@ async def test_get_coin_states(db_version: int) -> None:
 
 @dataclass(frozen=True)
 class RandomCoinRecords:
-    items: List[CoinRecord]
-    puzzle_hashes: List[bytes32]
-    hints: List[Tuple[bytes32, bytes]]
+    items: list[CoinRecord]
+    puzzle_hashes: list[bytes32]
+    hints: list[tuple[bytes32, bytes]]
 
 
 @pytest.fixture(scope="session")
 def random_coin_records() -> RandomCoinRecords:
-    coin_records: List[CoinRecord] = []
-    puzzle_hashes: List[bytes32] = []
-    hints: List[Tuple[bytes32, bytes]] = []
+    coin_records: list[CoinRecord] = []
+    puzzle_hashes: list[bytes32] = []
+    hints: list[tuple[bytes32, bytes]] = []
 
     for i in range(50000):
         is_spent = i % 2 == 0
@@ -586,7 +595,7 @@ async def test_coin_state_batches(
             expected_crs.append(cr)
 
         height: Optional[uint32] = uint32(0)
-        all_coin_states: List[CoinState] = []
+        all_coin_states: list[CoinState] = []
         remaining_phs = random_coin_records.puzzle_hashes.copy()
 
         def height_of(coin_state: CoinState) -> int:
@@ -637,7 +646,7 @@ async def test_batch_many_coin_states(db_version: int, cut_off_middle: bool) ->
         ph = bytes32(b"0" * 32)
 
         # Generate coin records.
-        coin_records: List[CoinRecord] = []
+        coin_records: list[CoinRecord] = []
         count = 50000
 
         for i in range(count):
@@ -760,7 +769,7 @@ class UnspentLineageInfoTestItem:
 @dataclass
 class UnspentLineageInfoCase:
     id: str
-    items: List[UnspentLineageInfoTestItem]
+    items: list[UnspentLineageInfoTestItem]
     expected_success: bool
     parent_with_diff_amount: bool = False
     marks: Marks = ()
@@ -831,7 +840,7 @@ class UnspentLineageInfoCase:
     ),
 )
 async def test_get_unspent_lineage_info_for_puzzle_hash(case: UnspentLineageInfoCase) -> None:
-    CoinRecordRawData = Tuple[
+    CoinRecordRawData = tuple[
         bytes,  # coin_name (blob)
         int,  # confirmed_index (bigint)
         int,  # spent_index (bigint)
@@ -842,7 +851,7 @@ async def test_get_unspent_lineage_info_for_puzzle_hash(case: UnspentLineageInfo
         int,  # timestamp (bigint)
     ]
 
-    def make_test_data(test_items: List[UnspentLineageInfoTestItem]) -> List[CoinRecordRawData]:
+    def make_test_data(test_items: list[UnspentLineageInfoTestItem]) -> list[CoinRecordRawData]:
         test_data = []
         for item in test_items:
             test_data.append(

chia/_tests/core/full_node/stores/test_full_node_store.py

@@ -2,13 +2,15 @@ from __future__ import annotations
 
 import logging
 import random
-from typing import AsyncIterator, Dict, List, Optional, Tuple
+from collections.abc import AsyncIterator
+from typing import Optional
 
 import pytest
 
 from chia._tests.blockchain.blockchain_test_utils import _validate_and_add_block, _validate_and_add_block_no_error
 from chia._tests.util.blockchain import create_blockchain
 from chia._tests.util.blockchain_mock import BlockchainMock
+from chia.consensus.block_body_validation import ForkInfo
 from chia.consensus.blockchain import AddBlockResult, Blockchain
 from chia.consensus.constants import ConsensusConstants
 from chia.consensus.default_constants import DEFAULT_CONSTANTS
@@ -48,7 +50,7 @@ async def empty_blockchain(db_version: int, blockchain_constants: ConsensusConst
         DISCRIMINANT_SIZE_BITS=uint16(32),
         SUB_SLOT_ITERS_STARTING=uint64(2**12),
     )
-    async with create_blockchain(patched_constants, db_version) as (bc1, db_wrapper):
+    async with create_blockchain(patched_constants, db_version) as (bc1, _):
         yield bc1
 
 
@@ -56,7 +58,7 @@ async def empty_blockchain(db_version: int, blockchain_constants: ConsensusConst
 async def empty_blockchain_with_original_constants(
     db_version: int, blockchain_constants: ConsensusConstants
 ) -> AsyncIterator[Blockchain]:
-    async with create_blockchain(blockchain_constants, db_version) as (bc1, db_wrapper):
+    async with create_blockchain(blockchain_constants, db_version) as (bc1, _):
         yield bc1
 
 
@@ -82,7 +84,7 @@ async def test_unfinished_block_rank(
     # create variants of the unfinished block, where all we do is to change
     # the foliage_transaction_block_hash. As if they all had different foliage,
     # but the same reward block hash (i.e. the same proof-of-space)
-    unfinished: List[UnfinishedBlock] = [
+    unfinished: list[UnfinishedBlock] = [
         recursive_replace(unf, "foliage.foliage_transaction_block_hash", bytes32([idx + 4] * 32))
         for idx in range(num_duplicates)
     ]
@@ -93,9 +95,7 @@ async def test_unfinished_block_rank(
     # shuffle them to ensure the order we add them to the store isn't relevant
     seeded_random.shuffle(unfinished)
     for new_unf in unfinished:
-        store.add_unfinished_block(
-            uint32(2), new_unf, PreValidationResult(None, uint64(123532), None, False, uint32(0))
-        )
+        store.add_unfinished_block(uint32(2), new_unf, PreValidationResult(None, uint64(123532), None, uint32(0)))
 
     # now ask for "the" unfinished block given the proof-of-space.
     # the FullNodeStore should return the one with the lowest foliage tx block
@@ -130,12 +130,12 @@ async def test_unfinished_block_rank(
 )
 async def test_find_best_block(
     seeded_random: random.Random,
-    blocks: List[Tuple[Optional[int], bool]],
+    blocks: list[tuple[Optional[int], bool]],
     expected: Optional[int],
-    default_400_blocks: List[FullBlock],
+    default_400_blocks: list[FullBlock],
     bt: BlockTools,
 ) -> None:
-    result: Dict[Optional[bytes32], UnfinishedBlockEntry] = {}
+    result: dict[Optional[bytes32], UnfinishedBlockEntry] = {}
     i = 0
     for b, with_unf in blocks:
         unf: Optional[UnfinishedBlock]
@@ -149,7 +149,7 @@ async def test_find_best_block(
         else:
             result[bytes32(b.to_bytes(1, "big") * 32)] = UnfinishedBlockEntry(unf, None, uint32(123))
 
-    foliage_hash, block = find_best_block(result)
+    foliage_hash, _block = find_best_block(result)
     if expected is None:
         assert foliage_hash is None
     else:
@@ -219,7 +219,7 @@ async def test_basic_store(
         assert store.get_unfinished_block(unf_block.partial_hash) is None
         assert store.get_unfinished_block2(unf_block.partial_hash, None) == (None, 0, False)
         store.add_unfinished_block(
-            uint32(height), unf_block, PreValidationResult(None, uint64(123532), None, False, uint32(0))
+            uint32(height), unf_block, PreValidationResult(None, uint64(123532), None, uint32(0))
         )
         assert store.get_unfinished_block(unf_block.partial_hash) == unf_block
         assert store.get_unfinished_block2(
@@ -275,9 +275,7 @@ async def test_basic_store(
     assert unf3.foliage.foliage_transaction_block_hash is None
     assert unf4.foliage.foliage_transaction_block_hash is None
     for val, unf_block in enumerate([unf1, unf2, unf3, unf4]):
-        store.add_unfinished_block(
-            uint32(height), unf_block, PreValidationResult(None, uint64(val), None, False, uint32(0))
-        )
+        store.add_unfinished_block(uint32(height), unf_block, PreValidationResult(None, uint64(val), None, uint32(0)))
 
     # when not specifying a foliage hash, you get the "best" one
     # best is defined as the lowest foliage hash
@@ -454,8 +452,9 @@ async def test_basic_store(
         normalized_to_identity_cc_sp=normalized_to_identity,
     )
 
+    fork_info = ForkInfo(blocks[0].height - 1, blocks[0].height - 1, blocks[0].prev_header_hash)
     for block in blocks:
-        await _validate_and_add_block_no_error(blockchain, block)
+        await _validate_and_add_block_no_error(blockchain, block, fork_info=fork_info)
         sb = blockchain.block_record(block.header_hash)
         next_sub_slot_iters, next_difficulty = get_next_sub_slot_iters_and_difficulty(
             blockchain.constants, False, sb, blockchain
@@ -476,11 +475,13 @@ async def test_basic_store(
         normalized_to_identity_cc_ip=normalized_to_identity,
         normalized_to_identity_cc_sp=normalized_to_identity,
     )
+
+    fork_info = ForkInfo(-1, -1, blockchain.constants.GENESIS_CHALLENGE)
     for block in blocks_reorg:
         peak = blockchain.get_peak()
         assert peak is not None
 
-        await _validate_and_add_block_no_error(blockchain, block)
+        await _validate_and_add_block_no_error(blockchain, block, fork_info=fork_info)
 
         peak_here = blockchain.get_peak()
         assert peak_here is not None
@@ -558,7 +559,7 @@ async def test_basic_store(
             normalized_to_identity_cc_ip=normalized_to_identity,
             normalized_to_identity_cc_sp=normalized_to_identity,
         )
-        await _validate_and_add_block(blockchain, blocks[-1])
+        await _validate_and_add_block(blockchain, blocks[-1], fork_info=fork_info)
         peak_here = blockchain.get_peak()
         assert peak_here is not None
         if peak_here.header_hash == blocks[-1].header_hash:
@@ -834,6 +835,7 @@ async def test_basic_store(
 
     # Test future EOS cache
     store.initialize_genesis_sub_slot()
+    fork_info = ForkInfo(-1, -1, blockchain.constants.GENESIS_CHALLENGE)
     blocks = custom_block_tools.get_consecutive_blocks(
         1,
         normalized_to_identity_cc_eos=normalized_to_identity,
@@ -841,7 +843,7 @@ async def test_basic_store(
         normalized_to_identity_cc_ip=normalized_to_identity,
         normalized_to_identity_cc_sp=normalized_to_identity,
     )
-    await _validate_and_add_block_no_error(blockchain, blocks[-1])
+    await _validate_and_add_block_no_error(blockchain, blocks[-1], fork_info=fork_info)
     while True:
         blocks = custom_block_tools.get_consecutive_blocks(
             1,
@@ -851,7 +853,7 @@ async def test_basic_store(
             normalized_to_identity_cc_ip=normalized_to_identity,
             normalized_to_identity_cc_sp=normalized_to_identity,
         )
-        await _validate_and_add_block_no_error(blockchain, blocks[-1])
+        await _validate_and_add_block_no_error(blockchain, blocks[-1], fork_info=fork_info)
         sb = blockchain.block_record(blocks[-1].header_hash)
         if sb.first_in_sub_slot:
             break
@@ -910,8 +912,9 @@ async def test_basic_store(
         normalized_to_identity_icc_eos=normalized_to_identity,
     )
 
+    fork_info = ForkInfo(-1, -1, blockchain.constants.GENESIS_CHALLENGE)
     for block in blocks[:5]:
-        await _validate_and_add_block_no_error(blockchain, block)
+        await _validate_and_add_block_no_error(blockchain, block, fork_info=fork_info)
         sb = blockchain.block_record(block.header_hash)
         result = await blockchain.get_sp_and_ip_sub_slots(block.header_hash)
         assert result is not None
@@ -940,7 +943,7 @@ async def test_basic_store(
         )
         store.add_to_future_ip(new_ip)
 
-        await _validate_and_add_block_no_error(blockchain, prev_block)
+        await _validate_and_add_block_no_error(blockchain, prev_block, fork_info=fork_info)
         result = await blockchain.get_sp_and_ip_sub_slots(prev_block.header_hash)
         assert result is not None
         sp_sub_slot, ip_sub_slot = result
@@ -958,7 +961,7 @@ async def test_basic_store(
         else:
             case_1 = True
             assert res.new_infusion_points == []
-            found_ips: List[timelord_protocol.NewInfusionPointVDF] = []
+            found_ips: list[timelord_protocol.NewInfusionPointVDF] = []
             peak = blockchain.get_peak()
 
             for ss in block.finished_sub_slots:
@@ -981,14 +984,15 @@ async def test_basic_store(
     #     i2 .........  i1
     # Then do a reorg up to B2, removing all signage points after B2, but not before
     log.warning(f"Adding blocks up to {blocks[-1]}")
+    fork_info = ForkInfo(-1, -1, blockchain.constants.GENESIS_CHALLENGE)
     for block in blocks:
-        await _validate_and_add_block_no_error(blockchain, block)
+        await _validate_and_add_block_no_error(blockchain, block, fork_info=fork_info)
 
     log.warning("Starting loop")
     while True:
         log.warning("Looping")
         blocks = custom_block_tools.get_consecutive_blocks(1, block_list_input=blocks, skip_slots=1)
-        await _validate_and_add_block_no_error(blockchain, blocks[-1])
+        await _validate_and_add_block_no_error(blockchain, blocks[-1], fork_info=fork_info)
         peak = blockchain.get_peak()
         assert peak is not None
         result = await blockchain.get_sp_and_ip_sub_slots(peak.header_hash)
@@ -1015,7 +1019,7 @@ async def test_basic_store(
             and i1 > (i2 + 3)
         ):
             # We hit all the conditions that we want
-            all_sps: List[Optional[SignagePoint]] = [None] * custom_block_tools.constants.NUM_SPS_SUB_SLOT
+            all_sps: list[Optional[SignagePoint]] = [None] * custom_block_tools.constants.NUM_SPS_SUB_SLOT
 
             def assert_sp_none(sp_index: int, is_none: bool) -> None:
                 sp_to_check: Optional[SignagePoint] = all_sps[sp_index]
@@ -1041,7 +1045,7 @@ async def test_basic_store(
                 assert store.new_signage_point(uint8(i), blockchain, peak, peak.sub_slot_iters, sp)
 
             # Adding a new peak clears all SPs after that peak
-            await _validate_and_add_block_no_error(blockchain, blocks[-2])
+            await _validate_and_add_block_no_error(blockchain, blocks[-2], fork_info=fork_info)
             peak = blockchain.get_peak()
             assert peak is not None
             result = await blockchain.get_sp_and_ip_sub_slots(peak.header_hash)
@@ -1089,7 +1093,7 @@ async def test_basic_store(
             assert_sp_none(i1 + 1, False)
             assert_sp_none(i1 + 4, False)
 
-            await _validate_and_add_block_no_error(blockchain, blocks[-1])
+            await _validate_and_add_block_no_error(blockchain, blocks[-1], fork_info=fork_info)
             peak = blockchain.get_peak()
             assert peak is not None
             result = await blockchain.get_sp_and_ip_sub_slots(peak.header_hash)
@@ -1119,14 +1123,14 @@ async def test_basic_store(
             break
         else:
             for block in blocks[-2:]:
-                await _validate_and_add_block_no_error(blockchain, block)
+                await _validate_and_add_block_no_error(blockchain, block, fork_info=fork_info)
 
 
 @pytest.mark.limit_consensus_modes(reason="save time")
 @pytest.mark.anyio
 async def test_long_chain_slots(
     empty_blockchain_with_original_constants: Blockchain,
-    default_1000_blocks: List[FullBlock],
+    default_1000_blocks: list[FullBlock],
 ) -> None:
     blockchain = empty_blockchain_with_original_constants
     store = FullNodeStore(blockchain.constants)

chia/_tests/core/full_node/stores/test_hint_store.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import logging
-from typing import Tuple
 
 import pytest
 from clvm.casts import int_to_bytes
@@ -141,11 +140,11 @@ async def test_coin_ids_multi(db_version: int) -> None:
 
 @pytest.mark.anyio
 async def test_hints_in_blockchain(
-    wallet_nodes: Tuple[
+    wallet_nodes: tuple[
         FullNodeSimulator, FullNodeSimulator, ChiaServer, ChiaServer, WalletTool, WalletTool, BlockTools
     ],
 ) -> None:
-    full_node_1, full_node_2, server_1, server_2, wallet_a, wallet_receiver, bt = wallet_nodes
+    full_node_1, _full_node_2, _server_1, _server_2, _wallet_a, _wallet_receiver, bt = wallet_nodes
 
     blocks = bt.get_consecutive_blocks(
         5,
@@ -161,7 +160,7 @@ async def test_hints_in_blockchain(
     puzzle_hash = bytes32(32 * b"\0")
     amount = int_to_bytes(1)
     hint = bytes32(32 * b"\5")
-    coin_spent = list(blocks[-1].get_included_reward_coins())[0]
+    coin_spent = blocks[-1].get_included_reward_coins()[0]
     condition_dict = {
         ConditionOpcode.CREATE_COIN: [ConditionWithArgs(ConditionOpcode.CREATE_COIN, [puzzle_hash, amount, hint])]
     }