chia-blockchain 2.5.2rc1__py3-none-any.whl → 2.5.3rc1__py3-none-any.whl

chia/_tests/core/full_node/test_full_node.py

@@ -7,17 +7,23 @@ import logging
 import random
 import time
 from collections.abc import Awaitable, Coroutine
-from typing import Optional
+from typing import Any, Optional
 
 import pytest
 from chia_rs import (
     AugSchemeMPL,
+    Foliage,
+    FoliageTransactionBlock,
     G2Element,
     PrivateKey,
+    RewardChainBlockUnfinished,
     SpendBundleConditions,
+    TransactionsInfo,
     additions_and_removals,
     get_flags_for_height_and_constants,
 )
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint8, uint16, uint32, uint64, uint128
 from clvm.casts import int_to_bytes
 from packaging.version import Version
 
@@ -28,9 +34,10 @@ from chia._tests.core.full_node.stores.test_coin_store import get_future_reward_
 from chia._tests.core.make_block_generator import make_spend_bundle
 from chia._tests.core.node_height import node_height_at_least
 from chia._tests.util.misc import wallet_height_at_least
-from chia._tests.util.setup_nodes import SimulatorsAndWalletsServices
+from chia._tests.util.setup_nodes import OldSimulatorsAndWallets, SimulatorsAndWalletsServices
 from chia._tests.util.time_out_assert import time_out_assert, time_out_assert_custom_interval, time_out_messages
 from chia.consensus.block_body_validation import ForkInfo
+from chia.consensus.blockchain import Blockchain
 from chia.consensus.multiprocess_validation import PreValidationResult, pre_validate_block
 from chia.consensus.pot_iterations import is_overflow_block
 from chia.full_node.coin_store import CoinStore
@@ -40,11 +47,12 @@ from chia.full_node.signage_point import SignagePoint
 from chia.full_node.sync_store import Peak
 from chia.protocols import full_node_protocol, timelord_protocol, wallet_protocol
 from chia.protocols import full_node_protocol as fnp
-from chia.protocols.full_node_protocol import RespondTransaction
+from chia.protocols.full_node_protocol import NewTransaction, RespondTransaction
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
 from chia.protocols.shared_protocol import Capability, default_capabilities
 from chia.protocols.wallet_protocol import SendTransaction, TransactionAck
 from chia.server.address_manager import AddressManager
+from chia.server.node_discovery import FullNodePeers
 from chia.server.outbound_message import Message, NodeType
 from chia.server.server import ChiaServer
 from chia.simulator.add_blocks_in_batches import add_blocks_in_batches
@@ -61,12 +69,14 @@ from chia.simulator.setup_services import setup_full_node
 from chia.simulator.simulator_protocol import FarmNewBlockProtocol
 from chia.simulator.wallet_tools import WalletTool
 from chia.types.blockchain_format.classgroup import ClassgroupElement
-from chia.types.blockchain_format.foliage import Foliage, FoliageTransactionBlock, TransactionsInfo
 from chia.types.blockchain_format.program import Program
-from chia.types.blockchain_format.proof_of_space import ProofOfSpace, calculate_plot_id_pk, calculate_pos_challenge
-from chia.types.blockchain_format.reward_chain_block import RewardChainBlockUnfinished
+from chia.types.blockchain_format.proof_of_space import (
+    ProofOfSpace,
+    calculate_plot_id_ph,
+    calculate_plot_id_pk,
+    calculate_pos_challenge,
+)
 from chia.types.blockchain_format.serialized_program import SerializedProgram
-from chia.types.blockchain_format.sized_bytes import bytes32
 from chia.types.blockchain_format.vdf import CompressibleVDFField, VDFProof
 from chia.types.coin_record import CoinRecord
 from chia.types.coin_spend import make_spend
@@ -81,12 +91,13 @@ from chia.types.validation_state import ValidationState
 from chia.util.augmented_chain import AugmentedBlockchain
 from chia.util.errors import ConsensusError, Err
 from chia.util.hash import std_hash
-from chia.util.ints import uint8, uint16, uint32, uint64, uint128
 from chia.util.limited_semaphore import LimitedSemaphore
 from chia.util.recursive_replace import recursive_replace
 from chia.util.task_referencer import create_referenced_task
 from chia.util.vdf_prover import get_vdf_info_and_proof
+from chia.wallet.transaction_record import TransactionRecord
 from chia.wallet.util.tx_config import DEFAULT_TX_CONFIG
+from chia.wallet.wallet_node import WalletNode
 from chia.wallet.wallet_spend_bundle import WalletSpendBundle
 
 
@@ -100,7 +111,7 @@ def test_pre_validation_result() -> None:
     assert results.validated_signature is False
 
 
-async def new_transaction_not_requested(incoming, new_spend):
+async def new_transaction_not_requested(incoming: asyncio.Queue[Message], new_spend: NewTransaction) -> bool:
     await asyncio.sleep(3)
     while not incoming.empty():
         response = await incoming.get()
@@ -115,7 +126,7 @@ async def new_transaction_not_requested(incoming, new_spend):
     return True
 
 
-async def new_transaction_requested(incoming, new_spend):
+async def new_transaction_requested(incoming: asyncio.Queue[Message], new_spend: NewTransaction) -> bool:
     await asyncio.sleep(1)
     while not incoming.empty():
         response = await incoming.get()
@@ -130,23 +141,13 @@ async def new_transaction_requested(incoming, new_spend):
     return False
 
 
-async def get_block_path(full_node: FullNodeAPI):
-    blocks_list = [await full_node.full_node.blockchain.get_full_peak()]
-    assert blocks_list[0] is not None
-    while blocks_list[0].height != 0:
-        b = await full_node.full_node.block_store.get_full_block(blocks_list[0].prev_header_hash)
-        assert b is not None
-        blocks_list.insert(0, b)
-    return blocks_list
-
-
 @pytest.mark.anyio
 async def test_sync_no_farmer(
-    setup_two_nodes_and_wallet,
+    setup_two_nodes_and_wallet: OldSimulatorsAndWallets,
     default_1000_blocks: list[FullBlock],
     self_hostname: str,
     seeded_random: random.Random,
-):
+) -> None:
     nodes, _wallets, _bt = setup_two_nodes_and_wallet
     server_1 = nodes[0].full_node.server
     server_2 = nodes[1].full_node.server
@@ -164,7 +165,7 @@ async def test_sync_no_farmer(
     # connect the nodes and wait for node 2 to sync up to node 1
     await connect_and_get_peer(server_1, server_2, self_hostname)
 
-    def check_nodes_in_sync():
+    def check_nodes_in_sync() -> bool:
         p1 = full_node_2.full_node.blockchain.get_peak()
         p2 = full_node_1.full_node.blockchain.get_peak()
         return p1 == p2
@@ -176,8 +177,10 @@ async def test_sync_no_farmer(
 
 
 @pytest.mark.anyio
-@pytest.mark.parametrize("tx_size", [3000000000000])
-async def test_block_compression(setup_two_nodes_and_wallet, empty_blockchain, tx_size, self_hostname):
+@pytest.mark.parametrize("tx_size", [3_000_000_000_000])
+async def test_block_compression(
+    setup_two_nodes_and_wallet: OldSimulatorsAndWallets, empty_blockchain: Blockchain, tx_size: int, self_hostname: str
+) -> None:
     nodes, wallets, bt = setup_two_nodes_and_wallet
     server_1 = nodes[0].full_node.server
     server_2 = nodes[1].full_node.server
@@ -205,8 +208,8 @@ async def test_block_compression(setup_two_nodes_and_wallet, empty_blockchain, t
     # Send a transaction to mempool
     async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
         await wallet.generate_signed_transaction(
-            tx_size,
-            ph,
+            [uint64(tx_size)],
+            [ph],
             action_scope,
         )
     [tr] = action_scope.side_effects.transactions
@@ -224,8 +227,9 @@ async def test_block_compression(setup_two_nodes_and_wallet, empty_blockchain, t
     await time_out_assert(30, wallet_height_at_least, True, wallet_node_1, 5)
     await full_node_1.wait_for_wallet_synced(wallet_node=wallet_node_1, timeout=30)
 
-    async def check_transaction_confirmed(transaction) -> bool:
+    async def check_transaction_confirmed(transaction: TransactionRecord) -> bool:
         tx = await wallet_node_1.wallet_state_manager.get_transaction(transaction.name)
+        assert tx is not None
         return tx.confirmed
 
     await time_out_assert(30, check_transaction_confirmed, True, tr)
@@ -238,8 +242,8 @@ async def test_block_compression(setup_two_nodes_and_wallet, empty_blockchain, t
     # Send another tx
     async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
         await wallet.generate_signed_transaction(
-            20000,
-            ph,
+            [uint64(20_000)],
+            [ph],
             action_scope,
         )
     [tr] = action_scope.side_effects.transactions
@@ -260,7 +264,7 @@ async def test_block_compression(setup_two_nodes_and_wallet, empty_blockchain, t
     await time_out_assert(10, check_transaction_confirmed, True, tr)
 
     # Confirm generator is compressed
-    program: Optional[SerializedProgram] = (await full_node_1.get_all_full_blocks())[-1].transactions_generator
+    program = (await full_node_1.get_all_full_blocks())[-1].transactions_generator
     assert program is not None
     num_blocks = len((await full_node_1.get_all_full_blocks())[-1].transactions_generator_ref_list)
     # since the hard fork, we don't use this compression mechanism
@@ -278,8 +282,8 @@ async def test_block_compression(setup_two_nodes_and_wallet, empty_blockchain, t
     # Send another 2 tx
     async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
         await wallet.generate_signed_transaction(
-            30000,
-            ph,
+            [uint64(30_000)],
+            [ph],
             action_scope,
         )
     [tr] = action_scope.side_effects.transactions
@@ -291,8 +295,8 @@ async def test_block_compression(setup_two_nodes_and_wallet, empty_blockchain, t
     )
     async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
         await wallet.generate_signed_transaction(
-            40000,
-            ph,
+            [uint64(40_000)],
+            [ph],
             action_scope,
         )
     [tr] = action_scope.side_effects.transactions
@@ -305,8 +309,8 @@ async def test_block_compression(setup_two_nodes_and_wallet, empty_blockchain, t
 
     async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
         await wallet.generate_signed_transaction(
-            50000,
-            ph,
+            [uint64(50_000)],
+            [ph],
             action_scope,
         )
     [tr] = action_scope.side_effects.transactions
@@ -319,8 +323,8 @@ async def test_block_compression(setup_two_nodes_and_wallet, empty_blockchain, t
 
     async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=True) as action_scope:
         await wallet.generate_signed_transaction(
-            3000000000000,
-            ph,
+            [uint64(3_000_000_000_000)],
+            [ph],
             action_scope,
         )
     [tr] = action_scope.side_effects.transactions
@@ -341,7 +345,7 @@ async def test_block_compression(setup_two_nodes_and_wallet, empty_blockchain, t
     await time_out_assert(10, check_transaction_confirmed, True, tr)
 
     # Confirm generator is compressed
-    program: Optional[SerializedProgram] = (await full_node_1.get_all_full_blocks())[-1].transactions_generator
+    program = (await full_node_1.get_all_full_blocks())[-1].transactions_generator
     assert program is not None
     num_blocks = len((await full_node_1.get_all_full_blocks())[-1].transactions_generator_ref_list)
     # since the hard fork, we don't use this compression mechanism
@@ -351,11 +355,12 @@ async def test_block_compression(setup_two_nodes_and_wallet, empty_blockchain, t
     # Creates a standard_transaction and an anyone-can-spend tx
     async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=False) as action_scope:
         await wallet.generate_signed_transaction(
-            30000,
-            Program.to(1).get_tree_hash(),
+            [uint64(30_000)],
+            [Program.to(1).get_tree_hash()],
             action_scope,
         )
     [tr] = action_scope.side_effects.transactions
+    assert tr.spend_bundle is not None
     extra_spend = WalletSpendBundle(
         [
             make_spend(
@@ -374,6 +379,7 @@ async def test_block_compression(setup_two_nodes_and_wallet, empty_blockchain, t
         removals=new_spend_bundle.removals(),
     )
     [new_tr] = await wallet.wallet_state_manager.add_pending_transactions([new_tr])
+    assert new_tr.spend_bundle is not None
     await time_out_assert(
         10,
         full_node_2.full_node.mempool_manager.get_spendbundle,
@@ -392,18 +398,19 @@ async def test_block_compression(setup_two_nodes_and_wallet, empty_blockchain, t
 
     # Confirm generator is not compressed, #CAT creation has a cat spend
     all_blocks = await full_node_1.get_all_full_blocks()
-    program: Optional[SerializedProgram] = all_blocks[-1].transactions_generator
+    program = all_blocks[-1].transactions_generator
     assert program is not None
     assert len(all_blocks[-1].transactions_generator_ref_list) == 0
 
     # Make a standard transaction and an anyone-can-spend transaction
     async with wallet.wallet_state_manager.new_action_scope(DEFAULT_TX_CONFIG, push=False) as action_scope:
         await wallet.generate_signed_transaction(
-            30000,
-            Program.to(1).get_tree_hash(),
+            [uint64(30_000)],
+            [Program.to(1).get_tree_hash()],
             action_scope,
         )
     [tr] = action_scope.side_effects.transactions
+    assert tr.spend_bundle is not None
     extra_spend = WalletSpendBundle(
         [
             make_spend(
@@ -422,6 +429,7 @@ async def test_block_compression(setup_two_nodes_and_wallet, empty_blockchain, t
         removals=new_spend_bundle.removals(),
     )
     [new_tr] = await wallet.wallet_state_manager.add_pending_transactions([new_tr])
+    assert new_tr.spend_bundle is not None
     await time_out_assert(
         10,
         full_node_2.full_node.mempool_manager.get_spendbundle,
@@ -437,14 +445,16 @@ async def test_block_compression(setup_two_nodes_and_wallet, empty_blockchain, t
     await full_node_1.wait_for_wallet_synced(wallet_node=wallet_node_1, timeout=30)
 
     # Confirm generator is not compressed
-    program: Optional[SerializedProgram] = (await full_node_1.get_all_full_blocks())[-1].transactions_generator
+    program = (await full_node_1.get_all_full_blocks())[-1].transactions_generator
     assert program is not None
     assert len((await full_node_1.get_all_full_blocks())[-1].transactions_generator_ref_list) == 0
 
-    height = full_node_1.full_node.blockchain.get_peak().height
+    peak = full_node_1.full_node.blockchain.get_peak()
+    assert peak is not None
+    height = peak.height
 
     blockchain = empty_blockchain
-    all_blocks: list[FullBlock] = await full_node_1.get_all_full_blocks()
+    all_blocks = await full_node_1.get_all_full_blocks()
     assert height == len(all_blocks) - 1
 
     if test_reorgs:
@@ -492,14 +502,14 @@ async def test_block_compression(setup_two_nodes_and_wallet, empty_blockchain, t
 
 
 @pytest.mark.anyio
-async def test_spendbundle_serialization():
+async def test_spendbundle_serialization() -> None:
     sb: SpendBundle = make_spend_bundle(1)
     protocol_message = RespondTransaction(sb)
     assert bytes(sb) == bytes(protocol_message)
 
 
 @pytest.mark.anyio
-async def test_inbound_connection_limit(setup_four_nodes, self_hostname):
+async def test_inbound_connection_limit(setup_four_nodes: OldSimulatorsAndWallets, self_hostname: str) -> None:
     nodes, _, _ = setup_four_nodes
     server_1 = nodes[0].full_node.server
     server_1.config["target_peer_count"] = 2
@@ -512,29 +522,45 @@ async def test_inbound_connection_limit(setup_four_nodes, self_hostname):
 
 
 @pytest.mark.anyio
-async def test_request_peers(wallet_nodes, self_hostname):
+async def test_request_peers(
+    wallet_nodes: tuple[
+        FullNodeSimulator, FullNodeSimulator, ChiaServer, ChiaServer, WalletTool, WalletTool, BlockTools
+    ],
+    self_hostname: str,
+) -> None:
     full_node_1, full_node_2, server_1, server_2, _wallet_a, _wallet_receiver, _ = wallet_nodes
+    assert full_node_2.full_node.full_node_peers is not None
+    assert full_node_2.full_node.full_node_peers.address_manager is not None
     full_node_2.full_node.full_node_peers.address_manager.make_private_subnets_valid()
     await server_2.start_client(PeerInfo(self_hostname, server_1.get_port()))
 
-    async def have_msgs():
-        await full_node_2.full_node.full_node_peers.address_manager.add_to_new_table(
-            [TimestampedPeerInfo("127.0.0.1", uint16(1000), uint64(int(time.time())) - 1000)],
+    async def have_msgs(full_node_peers: FullNodePeers) -> bool:
+        assert full_node_peers.address_manager is not None
+        await full_node_peers.address_manager.add_to_new_table(
+            [TimestampedPeerInfo("127.0.0.1", uint16(1000), uint64(int(time.time()) - 1000))],
             None,
         )
-        msg_bytes = await full_node_2.full_node.full_node_peers.request_peers(PeerInfo("::1", server_2._port))
+        assert server_2._port is not None
+        msg_bytes = await full_node_peers.request_peers(PeerInfo("::1", server_2._port))
+        assert msg_bytes is not None
         msg = fnp.RespondPeers.from_bytes(msg_bytes.data)
         if msg is not None and not (len(msg.peer_list) == 1):
             return False
         peer = msg.peer_list[0]
         return (peer.host in {self_hostname, "127.0.0.1"}) and peer.port == 1000
 
-    await time_out_assert_custom_interval(10, 1, have_msgs, True)
+    await time_out_assert_custom_interval(10, 1, have_msgs, True, full_node_2.full_node.full_node_peers)
+    assert full_node_1.full_node.full_node_peers is not None
     full_node_1.full_node.full_node_peers.address_manager = AddressManager()
 
 
 @pytest.mark.anyio
-async def test_basic_chain(wallet_nodes, self_hostname):
+async def test_basic_chain(
+    wallet_nodes: tuple[
+        FullNodeSimulator, FullNodeSimulator, ChiaServer, ChiaServer, WalletTool, WalletTool, BlockTools
+    ],
+    self_hostname: str,
+) -> None:
     full_node_1, _full_node_2, server_1, server_2, _wallet_a, _wallet_receiver, bt = wallet_nodes
 
     incoming_queue, _ = await add_dummy_connection(server_1, self_hostname, 12312)
@@ -549,17 +575,26 @@ async def test_basic_chain(wallet_nodes, self_hostname):
 
     await time_out_assert(10, time_out_messages(incoming_queue, "new_peak", 1))
 
-    assert full_node_1.full_node.blockchain.get_peak().height == 0
+    peak = full_node_1.full_node.blockchain.get_peak()
+    assert peak is not None
+    assert peak.height == 0
 
     fork_info = ForkInfo(-1, -1, bt.constants.GENESIS_CHALLENGE)
     for block in bt.get_consecutive_blocks(30):
         await full_node_1.full_node.add_block(block, peer, fork_info=fork_info)
 
-    assert full_node_1.full_node.blockchain.get_peak().height == 29
+    peak = full_node_1.full_node.blockchain.get_peak()
+    assert peak is not None
+    assert peak.height == 29
 
 
 @pytest.mark.anyio
-async def test_respond_end_of_sub_slot(wallet_nodes, self_hostname):
+async def test_respond_end_of_sub_slot(
+    wallet_nodes: tuple[
+        FullNodeSimulator, FullNodeSimulator, ChiaServer, ChiaServer, WalletTool, WalletTool, BlockTools
+    ],
+    self_hostname: str,
+) -> None:
     full_node_1, _full_node_2, server_1, server_2, _wallet_a, _wallet_receiver, bt = wallet_nodes
 
     incoming_queue, _dummy_node_id = await add_dummy_connection(server_1, self_hostname, 12312)
@@ -618,7 +653,12 @@ async def test_respond_end_of_sub_slot(wallet_nodes, self_hostname):
 
 
 @pytest.mark.anyio
-async def test_respond_end_of_sub_slot_no_reorg(wallet_nodes, self_hostname):
+async def test_respond_end_of_sub_slot_no_reorg(
+    wallet_nodes: tuple[
+        FullNodeSimulator, FullNodeSimulator, ChiaServer, ChiaServer, WalletTool, WalletTool, BlockTools
+    ],
+    self_hostname: str,
+) -> None:
     full_node_1, _full_node_2, server_1, server_2, _wallet_a, _wallet_receiver, bt = wallet_nodes
 
     incoming_queue, _dummy_node_id = await add_dummy_connection(server_1, self_hostname, 12312)
@@ -656,7 +696,12 @@ async def test_respond_end_of_sub_slot_no_reorg(wallet_nodes, self_hostname):
 
 
 @pytest.mark.anyio
-async def test_respond_end_of_sub_slot_race(wallet_nodes, self_hostname):
+async def test_respond_end_of_sub_slot_race(
+    wallet_nodes: tuple[
+        FullNodeSimulator, FullNodeSimulator, ChiaServer, ChiaServer, WalletTool, WalletTool, BlockTools
+    ],
+    self_hostname: str,
+) -> None:
     full_node_1, _full_node_2, server_1, server_2, _wallet_a, _wallet_receiver, bt = wallet_nodes
 
     incoming_queue, _dummy_node_id = await add_dummy_connection(server_1, self_hostname, 12312)
@@ -687,7 +732,12 @@ async def test_respond_end_of_sub_slot_race(wallet_nodes, self_hostname):
 
 
 @pytest.mark.anyio
-async def test_respond_unfinished(wallet_nodes, self_hostname):
+async def test_respond_unfinished(
+    wallet_nodes: tuple[
+        FullNodeSimulator, FullNodeSimulator, ChiaServer, ChiaServer, WalletTool, WalletTool, BlockTools
+    ],
+    self_hostname: str,
+) -> None:
     full_node_1, _full_node_2, server_1, server_2, wallet_a, wallet_receiver, bt = wallet_nodes
 
     incoming_queue, _dummy_node_id = await add_dummy_connection(server_1, self_hostname, 12312)
@@ -772,6 +822,7 @@ async def test_respond_unfinished(wallet_nodes, self_hostname):
     assert full_node_1.full_node.full_node_store.get_unfinished_block(unf.partial_hash) is None
     await full_node_1.full_node.add_unfinished_block(unf, None)
     assert full_node_1.full_node.full_node_store.get_unfinished_block(unf.partial_hash) is not None
+    assert unf.foliage.foliage_transaction_block_hash is not None
     entry = full_node_1.full_node.full_node_store.get_unfinished_block_result(
         unf.partial_hash, unf.foliage.foliage_transaction_block_hash
     )
@@ -781,17 +832,22 @@ async def test_respond_unfinished(wallet_nodes, self_hostname):
     assert result.conds is not None
     assert result.conds.cost > 0
 
-    assert not full_node_1.full_node.blockchain.contains_block(block.header_hash)
+    assert not full_node_1.full_node.blockchain.contains_block(block.header_hash, block.height)
     assert block.transactions_generator is not None
     block_no_transactions = block.replace(transactions_generator=None)
     assert block_no_transactions.transactions_generator is None
 
     await full_node_1.full_node.add_block(block_no_transactions)
-    assert full_node_1.full_node.blockchain.contains_block(block.header_hash)
+    assert full_node_1.full_node.blockchain.contains_block(block.header_hash, block.height)
 
 
 @pytest.mark.anyio
-async def test_new_peak(wallet_nodes, self_hostname):
+async def test_new_peak(
+    wallet_nodes: tuple[
+        FullNodeSimulator, FullNodeSimulator, ChiaServer, ChiaServer, WalletTool, WalletTool, BlockTools
+    ],
+    self_hostname: str,
+) -> None:
     full_node_1, _full_node_2, server_1, server_2, _wallet_a, _wallet_receiver, bt = wallet_nodes
 
     incoming_queue, dummy_node_id = await add_dummy_connection(server_1, self_hostname, 12312)
@@ -824,7 +880,7 @@ async def test_new_peak(wallet_nodes, self_hostname):
         await time_out_assert(10, time_out_messages(incoming_queue, "request_block", 0))
         task_2.cancel()
 
-    async def suppress_value_error(coro: Coroutine) -> None:
+    async def suppress_value_error(coro: Coroutine[Any, Any, None]) -> None:
         with contextlib.suppress(ValueError):
             await coro
 
@@ -852,7 +908,13 @@ async def test_new_peak(wallet_nodes, self_hostname):
 
 
 @pytest.mark.anyio
-async def test_new_transaction_and_mempool(wallet_nodes, self_hostname, seeded_random: random.Random):
+async def test_new_transaction_and_mempool(
+    wallet_nodes: tuple[
+        FullNodeSimulator, FullNodeSimulator, ChiaServer, ChiaServer, WalletTool, WalletTool, BlockTools
+    ],
+    self_hostname: str,
+    seeded_random: random.Random,
+) -> None:
     full_node_1, full_node_2, server_1, server_2, wallet_a, wallet_receiver, bt = wallet_nodes
     wallet_ph = wallet_a.get_new_puzzlehash()
     blocks = bt.get_consecutive_blocks(
@@ -864,18 +926,15 @@ async def test_new_transaction_and_mempool(wallet_nodes, self_hostname, seeded_r
     for block in blocks:
         await full_node_1.full_node.add_block(block)
 
-    start_height = (
-        full_node_1.full_node.blockchain.get_peak().height
-        if full_node_1.full_node.blockchain.get_peak() is not None
-        else -1
-    )
+    peak = full_node_1.full_node.blockchain.get_peak()
+    start_height = peak.height if peak is not None else -1
     peer = await connect_and_get_peer(server_1, server_2, self_hostname)
     incoming_queue, node_id = await add_dummy_connection(server_1, self_hostname, 12312)
     fake_peer = server_1.all_connections[node_id]
     puzzle_hashes = []
 
     # Makes a bunch of coins
-    conditions_dict: dict = {ConditionOpcode.CREATE_COIN: []}
+    conditions_dict: dict[ConditionOpcode, list[ConditionWithArgs]] = {ConditionOpcode.CREATE_COIN: []}
     # This should fit in one transaction
     for _ in range(100):
         receiver_puzzlehash = wallet_receiver.get_new_puzzlehash()
@@ -885,7 +944,7 @@ async def test_new_transaction_and_mempool(wallet_nodes, self_hostname, seeded_r
         conditions_dict[ConditionOpcode.CREATE_COIN].append(output)
 
     spend_bundle = wallet_a.generate_signed_transaction(
-        100,
+        uint64(100),
         puzzle_hashes[0],
         get_future_reward_coins(blocks[1])[0],
         condition_dic=conditions_dict,
@@ -954,7 +1013,7 @@ async def test_new_transaction_and_mempool(wallet_nodes, self_hostname, seeded_r
 
         fee_rate_for_med = full_node_1.full_node.mempool_manager.mempool.get_min_fee_rate(5000000)
         fee_rate_for_large = full_node_1.full_node.mempool_manager.mempool.get_min_fee_rate(50000000)
-        if fee_rate_for_large > fee_rate_for_med:
+        if fee_rate_for_med is not None and fee_rate_for_large is not None and fee_rate_for_large > fee_rate_for_med:
             seen_bigger_transaction_has_high_fee = True
 
         if req is not None and req.data == bytes(fnp.RespondTransaction(spend_bundle)):
@@ -966,7 +1025,8 @@ async def test_new_transaction_and_mempool(wallet_nodes, self_hostname, seeded_r
                 successful_bundle = spend_bundle
         else:
             assert full_node_1.full_node.mempool_manager.mempool.at_full_capacity(10500000 * group_size)
-            assert full_node_1.full_node.mempool_manager.mempool.get_min_fee_rate(10500000 * group_size) > 0
+            min_fee_rate = full_node_1.full_node.mempool_manager.mempool.get_min_fee_rate(10500000 * group_size)
+            assert min_fee_rate is not None and min_fee_rate > 0
             assert not force_high_fee
             not_included_tx += 1
     assert successful_bundle is not None
@@ -998,6 +1058,7 @@ async def test_new_transaction_and_mempool(wallet_nodes, self_hostname, seeded_r
 
     # Resubmission through wallet is also fine
     response_msg = await full_node_1.send_transaction(SendTransaction(successful_bundle), test=True)
+    assert response_msg is not None
     assert TransactionAck.from_bytes(response_msg.data).status == MempoolInclusionStatus.SUCCESS.value
 
     # Farm one block to clear mempool
@@ -1033,7 +1094,13 @@ async def test_new_transaction_and_mempool(wallet_nodes, self_hostname, seeded_r
 
 
 @pytest.mark.anyio
-async def test_request_respond_transaction(wallet_nodes, self_hostname, seeded_random: random.Random):
+async def test_request_respond_transaction(
+    wallet_nodes: tuple[
+        FullNodeSimulator, FullNodeSimulator, ChiaServer, ChiaServer, WalletTool, WalletTool, BlockTools
+    ],
+    self_hostname: str,
+    seeded_random: random.Random,
+) -> None:
     full_node_1, full_node_2, server_1, server_2, wallet_a, wallet_receiver, bt = wallet_nodes
     wallet_ph = wallet_a.get_new_puzzlehash()
     blocks = await full_node_1.get_all_full_blocks()
@@ -1065,7 +1132,7 @@ async def test_request_respond_transaction(wallet_nodes, self_hostname, seeded_r
     receiver_puzzlehash = wallet_receiver.get_new_puzzlehash()
 
     spend_bundle = wallet_a.generate_signed_transaction(
-        100, receiver_puzzlehash, blocks[-1].get_included_reward_coins()[0]
+        uint64(100), receiver_puzzlehash, blocks[-1].get_included_reward_coins()[0]
     )
     assert spend_bundle is not None
     respond_transaction = fnp.RespondTransaction(spend_bundle)
@@ -1082,7 +1149,13 @@ async def test_request_respond_transaction(wallet_nodes, self_hostname, seeded_r
 
 
 @pytest.mark.anyio
-async def test_respond_transaction_fail(wallet_nodes, self_hostname, seeded_random: random.Random):
+async def test_respond_transaction_fail(
+    wallet_nodes: tuple[
+        FullNodeSimulator, FullNodeSimulator, ChiaServer, ChiaServer, WalletTool, WalletTool, BlockTools
+    ],
+    self_hostname: str,
+    seeded_random: random.Random,
+) -> None:
     full_node_1, _full_node_2, server_1, server_2, wallet_a, wallet_receiver, bt = wallet_nodes
     blocks = await full_node_1.get_all_full_blocks()
     cb_ph = wallet_a.get_new_puzzlehash()
@@ -1115,7 +1188,7 @@ async def test_respond_transaction_fail(wallet_nodes, self_hostname, seeded_rand
     await time_out_assert(10, time_out_messages(incoming_queue, "new_peak", 3))
     # Invalid transaction does not propagate
     spend_bundle = wallet_a.generate_signed_transaction(
-        100000000000000,
+        uint64(100_000_000_000_000),
         receiver_puzzlehash,
         blocks_new[-1].get_included_reward_coins()[0],
     )
@@ -1130,7 +1203,11 @@ async def test_respond_transaction_fail(wallet_nodes, self_hostname, seeded_rand
 
 
 @pytest.mark.anyio
-async def test_request_block(wallet_nodes):
+async def test_request_block(
+    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
     blocks = await full_node_1.get_all_full_blocks()
 
@@ -1142,7 +1219,7 @@ async def test_request_block(wallet_nodes):
         pool_reward_puzzle_hash=wallet_a.get_new_puzzlehash(),
     )
     spend_bundle = wallet_a.generate_signed_transaction(
-        1123,
+        uint64(1123),
         wallet_receiver.get_new_puzzlehash(),
         blocks[-1].get_included_reward_coins()[0],
     )
@@ -1155,25 +1232,33 @@ async def test_request_block(wallet_nodes):
 
     # Don't have height
     res = await full_node_1.request_block(fnp.RequestBlock(uint32(1248921), False))
+    assert res is not None
     assert res.type == ProtocolMessageTypes.reject_block.value
 
     # Ask without transactions
     res = await full_node_1.request_block(fnp.RequestBlock(blocks[-1].height, False))
+    assert res is not None
     assert res.type != ProtocolMessageTypes.reject_block.value
     assert fnp.RespondBlock.from_bytes(res.data).block.transactions_generator is None
 
     # Ask with transactions
     res = await full_node_1.request_block(fnp.RequestBlock(blocks[-1].height, True))
+    assert res is not None
     assert res.type != ProtocolMessageTypes.reject_block.value
     assert fnp.RespondBlock.from_bytes(res.data).block.transactions_generator is not None
 
     # Ask for another one
-    res = await full_node_1.request_block(fnp.RequestBlock(blocks[-1].height - 1, True))
+    res = await full_node_1.request_block(fnp.RequestBlock(uint32(blocks[-1].height - 1), True))
+    assert res is not None
     assert res.type != ProtocolMessageTypes.reject_block.value
 
 
 @pytest.mark.anyio
-async def test_request_blocks(wallet_nodes):
+async def test_request_blocks(
+    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
     blocks = await full_node_1.get_all_full_blocks()
 
@@ -1187,7 +1272,7 @@ async def test_request_blocks(wallet_nodes):
     )
 
     spend_bundle = wallet_a.generate_signed_transaction(
-        1123,
+        uint64(1123),
         wallet_receiver.get_new_puzzlehash(),
         blocks[-1].get_included_reward_coins()[0],
     )
@@ -1207,18 +1292,21 @@ async def test_request_blocks(wallet_nodes):
     assert len(fetched_blocks) == 1
     assert fetched_blocks[0].header_hash == blocks[4].header_hash
     res = await full_node_1.request_blocks(fnp.RequestBlocks(uint32(5), uint32(4), False))
+    assert res is not None
     assert res.type == ProtocolMessageTypes.reject_blocks.value
     # Invalid range
     res = await full_node_1.request_blocks(fnp.RequestBlocks(uint32(peak_height - 5), uint32(peak_height + 5), False))
+    assert res is not None
     assert res.type == ProtocolMessageTypes.reject_blocks.value
 
     # Try fetching more blocks than constants.MAX_BLOCK_COUNT_PER_REQUESTS
     res = await full_node_1.request_blocks(fnp.RequestBlocks(uint32(0), uint32(33), False))
+    assert res is not None
     assert res.type == ProtocolMessageTypes.reject_blocks.value
 
     # Ask without transactions
     res = await full_node_1.request_blocks(fnp.RequestBlocks(uint32(peak_height - 5), uint32(peak_height), False))
-
+    assert res is not None
     fetched_blocks = fnp.RespondBlocks.from_bytes(res.data).blocks
     assert len(fetched_blocks) == 6
     for b in fetched_blocks:
@@ -1226,6 +1314,7 @@ async def test_request_blocks(wallet_nodes):
 
     # Ask with transactions
     res = await full_node_1.request_blocks(fnp.RequestBlocks(uint32(peak_height - 5), uint32(peak_height), True))
+    assert res is not None
     fetched_blocks = fnp.RespondBlocks.from_bytes(res.data).blocks
     assert len(fetched_blocks) == 6
     assert fetched_blocks[-1].transactions_generator is not None
@@ -1235,7 +1324,14 @@ async def test_request_blocks(wallet_nodes):
 @pytest.mark.anyio
 @pytest.mark.parametrize("peer_version", ["0.0.35", "0.0.36"])
 @pytest.mark.parametrize("requesting", [0, 1, 2])
-async def test_new_unfinished_block(wallet_nodes, peer_version: str, requesting: int, self_hostname: str):
+async def test_new_unfinished_block(
+    wallet_nodes: tuple[
+        FullNodeSimulator, FullNodeSimulator, ChiaServer, ChiaServer, WalletTool, WalletTool, BlockTools
+    ],
+    peer_version: str,
+    requesting: int,
+    self_hostname: str,
+) -> None:
     full_node_1, _full_node_2, server_1, server_2, _wallet_a, _wallet_receiver, bt = wallet_nodes
     blocks = await full_node_1.get_all_full_blocks()
 
@@ -1290,7 +1386,13 @@ async def test_new_unfinished_block(wallet_nodes, peer_version: str, requesting:
 
 @pytest.mark.anyio
 @pytest.mark.parametrize("requesting", [0, 1, 2])
-async def test_new_unfinished_block2(wallet_nodes, requesting: int, self_hostname: str):
+async def test_new_unfinished_block2(
+    wallet_nodes: tuple[
+        FullNodeSimulator, FullNodeSimulator, ChiaServer, ChiaServer, WalletTool, WalletTool, BlockTools
+    ],
+    requesting: int,
+    self_hostname: str,
+) -> None:
     full_node_1, _full_node_2, server_1, server_2, _wallet_a, _wallet_receiver, bt = wallet_nodes
     blocks = await full_node_1.get_all_full_blocks()
 
@@ -1330,7 +1432,12 @@ async def test_new_unfinished_block2(wallet_nodes, requesting: int, self_hostnam
 
 
 @pytest.mark.anyio
-async def test_new_unfinished_block2_forward_limit(wallet_nodes, self_hostname: str):
+async def test_new_unfinished_block2_forward_limit(
+    wallet_nodes: tuple[
+        FullNodeSimulator, FullNodeSimulator, ChiaServer, ChiaServer, WalletTool, WalletTool, BlockTools
+    ],
+    self_hostname: str,
+) -> None:
     full_node_1, _full_node_2, server_1, server_2, wallet_a, wallet_receiver, bt = wallet_nodes
     blocks = bt.get_consecutive_blocks(3, guarantee_transaction_block=True)
     for block in blocks:
@@ -1353,7 +1460,7 @@ async def test_new_unfinished_block2_forward_limit(wallet_nodes, self_hostname:
     for idx in range(0, 6):
         # we include a different transaction in each block. This makes the
         # foliage different in each of them, but the reward block (plot) the same
-        tx = wallet_a.generate_signed_transaction(100 * (idx + 1), puzzle_hash, coin)
+        tx = wallet_a.generate_signed_transaction(uint64(100 * (idx + 1)), puzzle_hash, coin)
 
         # note that we use the same chain to build the new block on top of every time
         block = bt.get_consecutive_blocks(
@@ -1404,7 +1511,14 @@ async def test_new_unfinished_block2_forward_limit(wallet_nodes, self_hostname:
         (7, Err.TOO_MANY_GENERATOR_REFS),
     ],
 )
-async def test_unfinished_block_with_replaced_generator(wallet_nodes, self_hostname, committment, expected):
+async def test_unfinished_block_with_replaced_generator(
+    wallet_nodes: tuple[
+        FullNodeSimulator, FullNodeSimulator, ChiaServer, ChiaServer, WalletTool, WalletTool, BlockTools
+    ],
+    self_hostname: str,
+    committment: int,
+    expected: Err,
+) -> None:
     full_node_1, _full_node_2, server_1, server_2, _wallet_a, _wallet_receiver, bt = wallet_nodes
     blocks = await full_node_1.get_all_full_blocks()
 
@@ -1418,6 +1532,7 @@ async def test_unfinished_block_with_replaced_generator(wallet_nodes, self_hostn
 
     if committment > 0:
         tr = block.transactions_info
+        assert tr is not None
         transactions_info = TransactionsInfo(
             std_hash(bytes(replaced_generator)),
             tr.generator_refs_root,
@@ -1427,10 +1542,12 @@ async def test_unfinished_block_with_replaced_generator(wallet_nodes, self_hostn
             tr.reward_claims_incorporated,
         )
     else:
+        assert block.transactions_info is not None
         transactions_info = block.transactions_info
 
     if committment > 1:
         tb = block.foliage_transaction_block
+        assert tb is not None
         transaction_block = FoliageTransactionBlock(
             tb.prev_transaction_block_hash,
             tb.timestamp,
@@ -1440,6 +1557,7 @@ async def test_unfinished_block_with_replaced_generator(wallet_nodes, self_hostn
             transactions_info.get_hash(),
         )
     else:
+        assert block.foliage_transaction_block is not None
         transaction_block = block.foliage_transaction_block
 
     if committment > 2:
@@ -1476,7 +1594,8 @@ async def test_unfinished_block_with_replaced_generator(wallet_nodes, self_hostn
 
             if committment > 5:
                 if pos.pool_public_key is None:
-                    plot_id = calculate_plot_id_pk(pos.pool_contract_puzzle_hash, public_key)
+                    assert pos.pool_contract_puzzle_hash is not None
+                    plot_id = calculate_plot_id_ph(pos.pool_contract_puzzle_hash, public_key)
                 else:
                     plot_id = calculate_plot_id_pk(pos.pool_public_key, public_key)
                 original_challenge_hash = block.reward_chain_block.pos_ss_cc_challenge_hash
@@ -1544,7 +1663,12 @@ async def test_unfinished_block_with_replaced_generator(wallet_nodes, self_hostn
 
 
 @pytest.mark.anyio
-async def test_double_blocks_same_pospace(wallet_nodes, self_hostname):
+async def test_double_blocks_same_pospace(
+    wallet_nodes: tuple[
+        FullNodeSimulator, FullNodeSimulator, ChiaServer, ChiaServer, WalletTool, WalletTool, BlockTools
+    ],
+    self_hostname: str,
+) -> None:
     full_node_1, full_node_2, server_1, server_2, wallet_a, wallet_receiver, bt = wallet_nodes
 
     incoming_queue, dummy_node_id = await add_dummy_connection(server_1, self_hostname, 12315)
@@ -1558,7 +1682,7 @@ async def test_double_blocks_same_pospace(wallet_nodes, self_hostname):
     blocks: list[FullBlock] = await full_node_1.get_all_full_blocks()
 
     coin = blocks[-1].get_included_reward_coins()[0]
-    tx = wallet_a.generate_signed_transaction(10000, wallet_receiver.get_new_puzzlehash(), coin)
+    tx = wallet_a.generate_signed_transaction(uint64(10_000), wallet_receiver.get_new_puzzlehash(), coin)
 
     blocks = bt.get_consecutive_blocks(
         1, block_list_input=blocks, guarantee_transaction_block=True, transaction_data=tx
@@ -1569,6 +1693,7 @@ async def test_double_blocks_same_pospace(wallet_nodes, self_hostname):
     await full_node_1.full_node.add_unfinished_block(unf, dummy_peer)
     assert full_node_1.full_node.full_node_store.get_unfinished_block(unf.partial_hash)
 
+    assert unf.foliage_transaction_block is not None
     block_2 = recursive_replace(
         blocks[-1], "foliage_transaction_block.timestamp", unf.foliage_transaction_block.timestamp + 1
     )
@@ -1584,14 +1709,19 @@ async def test_double_blocks_same_pospace(wallet_nodes, self_hostname):
 
 
 @pytest.mark.anyio
-async def test_request_unfinished_block(wallet_nodes, self_hostname):
+async def test_request_unfinished_block(
+    wallet_nodes: tuple[
+        FullNodeSimulator, FullNodeSimulator, ChiaServer, ChiaServer, WalletTool, WalletTool, BlockTools
+    ],
+    self_hostname: str,
+) -> None:
     full_node_1, _full_node_2, server_1, server_2, _wallet_a, _wallet_receiver, bt = wallet_nodes
     blocks = await full_node_1.get_all_full_blocks()
     peer = await connect_and_get_peer(server_1, server_2, self_hostname)
     blocks = bt.get_consecutive_blocks(10, block_list_input=blocks, seed=b"12345")
     for block in blocks[:-1]:
         await full_node_1.full_node.add_block(block)
-    block: FullBlock = blocks[-1]
+    block = blocks[-1]
     unf = make_unfinished_block(block, bt.constants)
 
     # Don't have
@@ -1604,7 +1734,12 @@ async def test_request_unfinished_block(wallet_nodes, self_hostname):
 
 
 @pytest.mark.anyio
-async def test_request_unfinished_block2(wallet_nodes, self_hostname):
+async def test_request_unfinished_block2(
+    wallet_nodes: tuple[
+        FullNodeSimulator, FullNodeSimulator, ChiaServer, ChiaServer, WalletTool, WalletTool, BlockTools
+    ],
+    self_hostname: str,
+) -> None:
     full_node_1, _full_node_2, server_1, server_2, wallet_a, wallet_receiver, bt = wallet_nodes
     blocks = await full_node_1.get_all_full_blocks()
     blocks = bt.get_consecutive_blocks(3, guarantee_transaction_block=True)
@@ -1622,7 +1757,7 @@ async def test_request_unfinished_block2(wallet_nodes, self_hostname):
     for idx in range(0, 6):
         # we include a different transaction in each block. This makes the
         # foliage different in each of them, but the reward block (plot) the same
-        tx = wallet_a.generate_signed_transaction(100 * (idx + 1), puzzle_hash, coin)
+        tx = wallet_a.generate_signed_transaction(uint64(100 * (idx + 1)), puzzle_hash, coin)
 
         # note that we use the same chain to build the new block on top of every time
         block = bt.get_consecutive_blocks(
@@ -1634,7 +1769,7 @@ async def test_request_unfinished_block2(wallet_nodes, self_hostname):
         if best_unf is None:
             best_unf = unf
         elif (
-            unf.foliage.foliage_transaction_block_hash is not None
+            best_unf.foliage.foliage_transaction_block_hash is not None
             and unf.foliage.foliage_transaction_block_hash < best_unf.foliage.foliage_transaction_block_hash
         ):
             best_unf = unf
@@ -1650,17 +1785,25 @@ async def test_request_unfinished_block2(wallet_nodes, self_hostname):
         res = await full_node_1.request_unfinished_block2(
             fnp.RequestUnfinishedBlock2(unf.partial_hash, unf.foliage.foliage_transaction_block_hash)
         )
+        assert res is not None
         assert res.data == bytes(fnp.RespondUnfinishedBlock(unf))
 
         res = await full_node_1.request_unfinished_block(fnp.RequestUnfinishedBlock(unf.partial_hash))
+        assert res is not None
         assert res.data == bytes(fnp.RespondUnfinishedBlock(best_unf))
 
         res = await full_node_1.request_unfinished_block2(fnp.RequestUnfinishedBlock2(unf.partial_hash, None))
+        assert res is not None
         assert res.data == bytes(fnp.RespondUnfinishedBlock(best_unf))
 
 
 @pytest.mark.anyio
-async def test_new_signage_point_or_end_of_sub_slot(wallet_nodes, self_hostname):
+async def test_new_signage_point_or_end_of_sub_slot(
+    wallet_nodes: tuple[
+        FullNodeSimulator, FullNodeSimulator, ChiaServer, ChiaServer, WalletTool, WalletTool, BlockTools
+    ],
+    self_hostname: str,
+) -> None:
     full_node_1, full_node_2, server_1, server_2, _wallet_a, _wallet_receiver, bt = wallet_nodes
     blocks = await full_node_1.get_all_full_blocks()
 
@@ -1671,7 +1814,7 @@ async def test_new_signage_point_or_end_of_sub_slot(wallet_nodes, self_hostname)
 
     blockchain = full_node_1.full_node.blockchain
     peak = blockchain.get_peak()
-
+    assert peak is not None
     sp = get_signage_point(
         bt.constants,
         blockchain,
@@ -1681,11 +1824,14 @@ async def test_new_signage_point_or_end_of_sub_slot(wallet_nodes, self_hostname)
         [],
         peak.sub_slot_iters,
     )
+    assert sp.cc_vdf is not None
+    assert sp.rc_vdf is not None
 
     peer = await connect_and_get_peer(server_1, server_2, self_hostname)
     res = await full_node_1.new_signage_point_or_end_of_sub_slot(
         fnp.NewSignagePointOrEndOfSubSlot(None, sp.cc_vdf.challenge, uint8(11), sp.rc_vdf.challenge), peer
     )
+    assert res is not None
     assert res.type == ProtocolMessageTypes.request_signage_point_or_end_of_sub_slot.value
     assert fnp.RequestSignagePointOrEndOfSubSlot.from_bytes(res.data).index_from_challenge == uint8(11)
 
@@ -1709,14 +1855,20 @@ async def test_new_signage_point_or_end_of_sub_slot(wallet_nodes, self_hostname)
 
     assert len(full_node_1.full_node.full_node_store.finished_sub_slots) >= num_slots
 
-    def caught_up_slots():
+    def caught_up_slots() -> bool:
         return len(full_node_2.full_node.full_node_store.finished_sub_slots) >= num_slots
 
     await time_out_assert(20, caught_up_slots)
 
 
 @pytest.mark.anyio
-async def test_new_signage_point_caching(wallet_nodes, empty_blockchain, self_hostname):
+async def test_new_signage_point_caching(
+    wallet_nodes: tuple[
+        FullNodeSimulator, FullNodeSimulator, ChiaServer, ChiaServer, WalletTool, WalletTool, BlockTools
+    ],
+    empty_blockchain: Blockchain,
+    self_hostname: str,
+) -> None:
     full_node_1, _full_node_2, server_1, server_2, _wallet_a, _wallet_receiver, bt = wallet_nodes
     blocks = await full_node_1.get_all_full_blocks()
 
@@ -1732,7 +1884,7 @@ async def test_new_signage_point_caching(wallet_nodes, empty_blockchain, self_ho
     blocks = bt.get_consecutive_blocks(1, block_list_input=blocks, skip_slots=1, force_overflow=True)
     for ss in blocks[-1].finished_sub_slots:
         challenge_chain = ss.challenge_chain.replace(
-            new_difficulty=20,
+            new_difficulty=uint64(20),
         )
         slot2 = ss.replace(
             challenge_chain=challenge_chain,
@@ -1745,6 +1897,7 @@ async def test_new_signage_point_caching(wallet_nodes, empty_blockchain, self_ho
 
     # Creates a signage point based on the last block
     peak_2 = second_blockchain.get_peak()
+    assert peak_2 is not None
     sp: SignagePoint = get_signage_point(
         bt.constants,
         blockchain,
@@ -1754,13 +1907,17 @@ async def test_new_signage_point_caching(wallet_nodes, empty_blockchain, self_ho
         [],
         peak_2.sub_slot_iters,
     )
+    assert sp.cc_vdf is not None
+    assert sp.cc_proof is not None
+    assert sp.rc_vdf is not None
+    assert sp.rc_proof is not None
     # Submits the signage point, cannot add because don't have block
     await full_node_1.respond_signage_point(
-        fnp.RespondSignagePoint(4, sp.cc_vdf, sp.cc_proof, sp.rc_vdf, sp.rc_proof), peer
+        fnp.RespondSignagePoint(uint8(4), sp.cc_vdf, sp.cc_proof, sp.rc_vdf, sp.rc_proof), peer
     )
     # Should not add duplicates to cache though
     await full_node_1.respond_signage_point(
-        fnp.RespondSignagePoint(4, sp.cc_vdf, sp.cc_proof, sp.rc_vdf, sp.rc_proof), peer
+        fnp.RespondSignagePoint(uint8(4), sp.cc_vdf, sp.cc_proof, sp.rc_vdf, sp.rc_proof), peer
     )
     assert full_node_1.full_node.full_node_store.get_signage_point(sp.cc_vdf.output.get_hash()) is None
     assert len(full_node_1.full_node.full_node_store.future_sp_cache[sp.rc_vdf.challenge]) == 1
@@ -1769,12 +1926,14 @@ async def test_new_signage_point_caching(wallet_nodes, empty_blockchain, self_ho
     await full_node_1.full_node.add_block(blocks[-1], peer)
 
     # Now signage point should be added
-    sp = full_node_1.full_node.full_node_store.get_signage_point(sp.cc_vdf.output.get_hash())
-    assert sp is not None
+    assert full_node_1.full_node.full_node_store.get_signage_point(sp.cc_vdf.output.get_hash()) is not None
 
 
 @pytest.mark.anyio
-async def test_slot_catch_up_genesis(setup_two_nodes_fixture, self_hostname):
+async def test_slot_catch_up_genesis(
+    setup_two_nodes_fixture: tuple[list[FullNodeSimulator], list[tuple[WalletNode, ChiaServer]], BlockTools],
+    self_hostname: str,
+) -> None:
     nodes, _, bt = setup_two_nodes_fixture
     server_1 = nodes[0].full_node.server
     server_2 = nodes[1].full_node.server
@@ -1799,14 +1958,16 @@ async def test_slot_catch_up_genesis(setup_two_nodes_fixture, self_hostname):
 
     assert len(full_node_1.full_node.full_node_store.finished_sub_slots) >= num_slots
 
-    def caught_up_slots():
+    def caught_up_slots() -> bool:
         return len(full_node_2.full_node.full_node_store.finished_sub_slots) >= num_slots
 
     await time_out_assert(20, caught_up_slots)
 
 
 @pytest.mark.anyio
-async def test_compact_protocol(setup_two_nodes_fixture):
+async def test_compact_protocol(
+    setup_two_nodes_fixture: tuple[list[FullNodeSimulator], list[tuple[WalletNode, ChiaServer]], BlockTools],
+) -> None:
     nodes, _, bt = setup_two_nodes_fixture
     full_node_1 = nodes[0]
     full_node_2 = nodes[1]
@@ -1831,7 +1992,7 @@ async def test_compact_protocol(setup_two_nodes_fixture):
                 vdf_proof,
                 block.header_hash,
                 block.height,
-                CompressibleVDFField.CC_EOS_VDF,
+                uint8(CompressibleVDFField.CC_EOS_VDF),
             )
         )
     blocks_2 = bt.get_consecutive_blocks(num_blocks=10, block_list_input=blocks, skip_slots=3)
@@ -1855,7 +2016,7 @@ async def test_compact_protocol(setup_two_nodes_fixture):
                     vdf_proof,
                     block.header_hash,
                     block.height,
-                    CompressibleVDFField.ICC_EOS_VDF,
+                    uint8(CompressibleVDFField.ICC_EOS_VDF),
                 )
             )
     assert block.reward_chain_block.challenge_chain_sp_vdf is not None
@@ -1872,7 +2033,7 @@ async def test_compact_protocol(setup_two_nodes_fixture):
             vdf_proof,
             block.header_hash,
             block.height,
-            CompressibleVDFField.CC_SP_VDF,
+            uint8(CompressibleVDFField.CC_SP_VDF),
         )
     )
     vdf_info, vdf_proof = get_vdf_info_and_proof(
@@ -1888,7 +2049,7 @@ async def test_compact_protocol(setup_two_nodes_fixture):
             vdf_proof,
             block.header_hash,
             block.height,
-            CompressibleVDFField.CC_IP_VDF,
+            uint8(CompressibleVDFField.CC_IP_VDF),
         )
     )
 
@@ -1921,11 +2082,16 @@ async def test_compact_protocol(setup_two_nodes_fixture):
     assert has_compact_cc_ip_vdf
     for height, block in enumerate(stored_blocks):
         await full_node_2.full_node.add_block(block)
-        assert full_node_2.full_node.blockchain.get_peak().height == height
+        peak = full_node_2.full_node.blockchain.get_peak()
+        assert peak is not None
+        assert peak.height == height
 
 
 @pytest.mark.anyio
-async def test_compact_protocol_invalid_messages(setup_two_nodes_fixture, self_hostname):
+async def test_compact_protocol_invalid_messages(
+    setup_two_nodes_fixture: tuple[list[FullNodeSimulator], list[tuple[WalletNode, ChiaServer]], BlockTools],
+    self_hostname: str,
+) -> None:
     nodes, _, bt = setup_two_nodes_fixture
     full_node_1 = nodes[0]
     full_node_2 = nodes[1]
@@ -1933,7 +2099,9 @@ async def test_compact_protocol_invalid_messages(setup_two_nodes_fixture, self_h
     blocks_2 = bt.get_consecutive_blocks(num_blocks=3, block_list_input=blocks, skip_slots=3)
     for block in blocks_2[:2]:
         await full_node_1.full_node.add_block(block)
-    assert full_node_1.full_node.blockchain.get_peak().height == 1
+    peak = full_node_1.full_node.blockchain.get_peak()
+    assert peak is not None
+    assert peak.height == 1
     # (wrong_vdf_info, wrong_vdf_proof) pair verifies, but it's not present in the blockchain at all.
     block = blocks_2[2]
     wrong_vdf_info, wrong_vdf_proof = get_vdf_info_and_proof(
@@ -1943,8 +2111,8 @@ async def test_compact_protocol_invalid_messages(setup_two_nodes_fixture, self_h
         block.reward_chain_block.challenge_chain_ip_vdf.number_of_iterations,
         True,
     )
-    timelord_protocol_invalid_messages = []
-    full_node_protocol_invalid_messaages = []
+    timelord_protocol_invalid_messages: list[timelord_protocol.RespondCompactProofOfTime] = []
+    full_node_protocol_invalid_messages: list[fnp.RespondCompactVDF] = []
     for block in blocks_2[:2]:
         for sub_slot in block.finished_sub_slots:
             vdf_info, correct_vdf_proof = get_vdf_info_and_proof(
@@ -1961,14 +2129,14 @@ async def test_compact_protocol_invalid_messages(setup_two_nodes_fixture, self_h
                     wrong_vdf_proof,
                     block.header_hash,
                     block.height,
-                    CompressibleVDFField.CC_EOS_VDF,
+                    uint8(CompressibleVDFField.CC_EOS_VDF),
                 )
             )
-            full_node_protocol_invalid_messaages.append(
+            full_node_protocol_invalid_messages.append(
                 fnp.RespondCompactVDF(
                     block.height,
                     block.header_hash,
-                    CompressibleVDFField.CC_EOS_VDF,
+                    uint8(CompressibleVDFField.CC_EOS_VDF),
                     vdf_info,
                     wrong_vdf_proof,
                 )
@@ -1988,14 +2156,14 @@ async def test_compact_protocol_invalid_messages(setup_two_nodes_fixture, self_h
                         wrong_vdf_proof,
                         block.header_hash,
                         block.height,
-                        CompressibleVDFField.ICC_EOS_VDF,
+                        uint8(CompressibleVDFField.ICC_EOS_VDF),
                     )
                 )
-                full_node_protocol_invalid_messaages.append(
+                full_node_protocol_invalid_messages.append(
                     fnp.RespondCompactVDF(
                         block.height,
                         block.header_hash,
-                        CompressibleVDFField.ICC_EOS_VDF,
+                        uint8(CompressibleVDFField.ICC_EOS_VDF),
                         vdf_info,
                         wrong_vdf_proof,
                     )
@@ -2019,14 +2187,14 @@ async def test_compact_protocol_invalid_messages(setup_two_nodes_fixture, self_h
                     sp_vdf_proof,
                     block.header_hash,
                     block.height,
-                    CompressibleVDFField.CC_SP_VDF,
+                    uint8(CompressibleVDFField.CC_SP_VDF),
                 )
             )
-            full_node_protocol_invalid_messaages.append(
+            full_node_protocol_invalid_messages.append(
                 fnp.RespondCompactVDF(
                     block.height,
                     block.header_hash,
-                    CompressibleVDFField.CC_SP_VDF,
+                    uint8(CompressibleVDFField.CC_SP_VDF),
                     vdf_info,
                     sp_vdf_proof,
                 )
@@ -2049,14 +2217,14 @@ async def test_compact_protocol_invalid_messages(setup_two_nodes_fixture, self_h
                 ip_vdf_proof,
                 block.header_hash,
                 block.height,
-                CompressibleVDFField.CC_IP_VDF,
+                uint8(CompressibleVDFField.CC_IP_VDF),
             )
         )
-        full_node_protocol_invalid_messaages.append(
+        full_node_protocol_invalid_messages.append(
             fnp.RespondCompactVDF(
                 block.height,
                 block.header_hash,
-                CompressibleVDFField.CC_IP_VDF,
+                uint8(CompressibleVDFField.CC_IP_VDF),
                 vdf_info,
                 ip_vdf_proof,
             )
@@ -2068,7 +2236,7 @@ async def test_compact_protocol_invalid_messages(setup_two_nodes_fixture, self_h
                 wrong_vdf_proof,
                 block.header_hash,
                 block.height,
-                CompressibleVDFField.CC_EOS_VDF,
+                uint8(CompressibleVDFField.CC_EOS_VDF),
             )
         )
         timelord_protocol_invalid_messages.append(
@@ -2077,7 +2245,7 @@ async def test_compact_protocol_invalid_messages(setup_two_nodes_fixture, self_h
                 wrong_vdf_proof,
                 block.header_hash,
                 block.height,
-                CompressibleVDFField.ICC_EOS_VDF,
+                uint8(CompressibleVDFField.ICC_EOS_VDF),
             )
         )
         timelord_protocol_invalid_messages.append(
@@ -2086,7 +2254,7 @@ async def test_compact_protocol_invalid_messages(setup_two_nodes_fixture, self_h
                 wrong_vdf_proof,
                 block.header_hash,
                 block.height,
-                CompressibleVDFField.CC_SP_VDF,
+                uint8(CompressibleVDFField.CC_SP_VDF),
             )
         )
         timelord_protocol_invalid_messages.append(
@@ -2095,41 +2263,41 @@ async def test_compact_protocol_invalid_messages(setup_two_nodes_fixture, self_h
                 wrong_vdf_proof,
                 block.header_hash,
                 block.height,
-                CompressibleVDFField.CC_IP_VDF,
+                uint8(CompressibleVDFField.CC_IP_VDF),
             )
         )
-        full_node_protocol_invalid_messaages.append(
+        full_node_protocol_invalid_messages.append(
             fnp.RespondCompactVDF(
                 block.height,
                 block.header_hash,
-                CompressibleVDFField.CC_EOS_VDF,
+                uint8(CompressibleVDFField.CC_EOS_VDF),
                 wrong_vdf_info,
                 wrong_vdf_proof,
             )
         )
-        full_node_protocol_invalid_messaages.append(
+        full_node_protocol_invalid_messages.append(
             fnp.RespondCompactVDF(
                 block.height,
                 block.header_hash,
-                CompressibleVDFField.ICC_EOS_VDF,
+                uint8(CompressibleVDFField.ICC_EOS_VDF),
                 wrong_vdf_info,
                 wrong_vdf_proof,
             )
         )
-        full_node_protocol_invalid_messaages.append(
+        full_node_protocol_invalid_messages.append(
             fnp.RespondCompactVDF(
                 block.height,
                 block.header_hash,
-                CompressibleVDFField.CC_SP_VDF,
+                uint8(CompressibleVDFField.CC_SP_VDF),
                 wrong_vdf_info,
                 wrong_vdf_proof,
             )
         )
-        full_node_protocol_invalid_messaages.append(
+        full_node_protocol_invalid_messages.append(
             fnp.RespondCompactVDF(
                 block.height,
                 block.header_hash,
-                CompressibleVDFField.CC_IP_VDF,
+                uint8(CompressibleVDFField.CC_IP_VDF),
                 wrong_vdf_info,
                 wrong_vdf_proof,
             )
@@ -2139,8 +2307,8 @@ async def test_compact_protocol_invalid_messages(setup_two_nodes_fixture, self_h
     peer = await connect_and_get_peer(server_1, server_2, self_hostname)
     for invalid_compact_proof in timelord_protocol_invalid_messages:
         await full_node_1.full_node.add_compact_proof_of_time(invalid_compact_proof)
-    for invalid_compact_proof in full_node_protocol_invalid_messaages:
-        await full_node_1.full_node.add_compact_vdf(invalid_compact_proof, peer)
+    for invalid_compact_vdf in full_node_protocol_invalid_messages:
+        await full_node_1.full_node.add_compact_vdf(invalid_compact_vdf, peer)
     stored_blocks = await full_node_1.get_all_full_blocks()
     for block in stored_blocks:
         for sub_slot in block.finished_sub_slots:
@@ -2153,7 +2321,9 @@ async def test_compact_protocol_invalid_messages(setup_two_nodes_fixture, self_h
 
 
 @pytest.mark.anyio
-async def test_respond_compact_proof_message_limit(setup_two_nodes_fixture):
+async def test_respond_compact_proof_message_limit(
+    setup_two_nodes_fixture: tuple[list[FullNodeSimulator], list[tuple[WalletNode, ChiaServer]], BlockTools],
+) -> None:
     nodes, _, bt = setup_two_nodes_fixture
     full_node_1 = nodes[0]
     full_node_2 = nodes[1]
@@ -2178,11 +2348,11 @@ async def test_respond_compact_proof_message_limit(setup_two_nodes_fixture):
                 vdf_proof,
                 block.header_hash,
                 block.height,
-                CompressibleVDFField.CC_IP_VDF,
+                uint8(CompressibleVDFField.CC_IP_VDF),
             )
         )
 
-    async def coro(full_node, compact_proof):
+    async def coro(full_node: FullNodeSimulator, compact_proof: timelord_protocol.RespondCompactProofOfTime) -> None:
         await full_node.respond_compact_proof_of_time(compact_proof)
 
     full_node_1.full_node._compact_vdf_sem = LimitedSemaphore.create(active_limit=1, waiting_limit=2)
@@ -2370,12 +2540,12 @@ async def validate_coin_set(coin_store: CoinStore, blocks: list[FullBlock]) -> N
 @pytest.mark.parametrize("light_blocks", [True, False])
 async def test_long_reorg(
     light_blocks: bool,
-    one_node_one_block,
+    one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools],
     default_10000_blocks: list[FullBlock],
     test_long_reorg_1500_blocks: list[FullBlock],
     test_long_reorg_1500_blocks_light: list[FullBlock],
     seeded_random: random.Random,
-):
+) -> None:
     node, _server, _bt = one_node_one_block
 
     fork_point = 1499
@@ -2390,6 +2560,7 @@ async def test_long_reorg(
 
     await add_blocks_in_batches(blocks, node.full_node)
     peak = node.full_node.blockchain.get_peak()
+    assert peak is not None
     chain_1_height = peak.height
     chain_1_weight = peak.weight
     chain_1_peak = peak.header_hash
@@ -2397,6 +2568,7 @@ async def test_long_reorg(
     assert reorg_blocks[fork_point] == default_10000_blocks[fork_point]
     assert reorg_blocks[fork_point + 1] != default_10000_blocks[fork_point + 1]
 
+    assert node.full_node._coin_store is not None
     await validate_coin_set(node.full_node._coin_store, blocks)
 
     # one aspect of this test is to make sure we can reorg blocks that are
@@ -2406,6 +2578,7 @@ async def test_long_reorg(
     await add_blocks_in_batches(reorg_blocks, node.full_node)
     # if these asserts fires, there was no reorg
     peak = node.full_node.blockchain.get_peak()
+    assert peak is not None
     assert peak.header_hash != chain_1_peak
     assert peak.weight > chain_1_weight
     chain_2_weight = peak.weight
@@ -2424,7 +2597,7 @@ async def test_long_reorg(
     # this exercises the case where we have some of the blocks in the DB already
     node.full_node.blockchain.clean_block_records()
     # when using add_block manualy we must warmup the cache
-    await node.full_node.blockchain.warmup(fork_point - 100)
+    await node.full_node.blockchain.warmup(uint32(fork_point - 100))
     if light_blocks:
         blocks = default_10000_blocks[fork_point - 100 : 3200]
     else:
@@ -2432,6 +2605,7 @@ async def test_long_reorg(
     await add_blocks_in_batches(blocks, node.full_node)
     # if these asserts fires, there was no reorg back to the original chain
     peak = node.full_node.blockchain.get_peak()
+    assert peak is not None
     assert peak.header_hash != chain_2_peak
     assert peak.weight > chain_2_weight
 
@@ -2447,7 +2621,7 @@ async def test_long_reorg_nodes(
     light_blocks: bool,
     chain_length: int,
     fork_point: int,
-    three_nodes,
+    three_nodes: list[FullNodeAPI],
     default_10000_blocks: list[FullBlock],
     test_long_reorg_blocks: list[FullBlock],
     test_long_reorg_blocks_light: list[FullBlock],
@@ -2455,9 +2629,13 @@ async def test_long_reorg_nodes(
     test_long_reorg_1500_blocks_light: list[FullBlock],
     self_hostname: str,
     seeded_random: random.Random,
-):
+) -> None:
     full_node_1, full_node_2, full_node_3 = three_nodes
 
+    assert full_node_1.full_node._coin_store is not None
+    assert full_node_2.full_node._coin_store is not None
+    assert full_node_3.full_node._coin_store is not None
+
     if fork_point == 1500:
         blocks = default_10000_blocks[: 3600 - chain_length]
     else:
@@ -2492,13 +2670,14 @@ async def test_long_reorg_nodes(
 
     start = time.monotonic()
 
-    def check_nodes_in_sync():
+    def check_nodes_in_sync() -> bool:
         p1 = full_node_2.full_node.blockchain.get_peak()
         p2 = full_node_1.full_node.blockchain.get_peak()
         return p1 == p2
 
     await time_out_assert(100, check_nodes_in_sync)
     peak = full_node_2.full_node.blockchain.get_peak()
+    assert peak is not None
     print(f"peak: {str(peak.header_hash)[:6]}")
 
     reorg1_timing = time.monotonic() - start
@@ -2506,7 +2685,9 @@ async def test_long_reorg_nodes(
     p1 = full_node_1.full_node.blockchain.get_peak()
     p2 = full_node_2.full_node.blockchain.get_peak()
 
+    assert p1 is not None
     assert p1.header_hash == reorg_blocks[-1].header_hash
+    assert p2 is not None
     assert p2.header_hash == reorg_blocks[-1].header_hash
 
     await validate_coin_set(full_node_1.full_node._coin_store, reorg_blocks)
@@ -2526,7 +2707,7 @@ async def test_long_reorg_nodes(
 
     start = time.monotonic()
 
-    def check_nodes_in_sync2():
+    def check_nodes_in_sync2() -> bool:
         p1 = full_node_1.full_node.blockchain.get_peak()
         p2 = full_node_2.full_node.blockchain.get_peak()
         p3 = full_node_3.full_node.blockchain.get_peak()
@@ -2540,8 +2721,11 @@ async def test_long_reorg_nodes(
     p2 = full_node_2.full_node.blockchain.get_peak()
     p3 = full_node_3.full_node.blockchain.get_peak()
 
+    assert p1 is not None
     assert p1.header_hash == blocks[-1].header_hash
+    assert p2 is not None
     assert p2.header_hash == blocks[-1].header_hash
+    assert p3 is not None
     assert p3.header_hash == blocks[-1].header_hash
 
     print(f"reorg1 timing: {reorg1_timing:0.2f}s")
@@ -2553,11 +2737,7 @@ async def test_long_reorg_nodes(
 
 
 @pytest.mark.anyio
-async def test_shallow_reorg_nodes(
-    three_nodes,
-    self_hostname: str,
-    bt: BlockTools,
-):
+async def test_shallow_reorg_nodes(three_nodes: list[FullNodeAPI], self_hostname: str, bt: BlockTools) -> None:
     full_node_1, full_node_2, _ = three_nodes
 
     # node 1 has chan A, then we replace the top block and ensure
@@ -2584,7 +2764,7 @@ async def test_shallow_reorg_nodes(
             if coin.puzzle_hash == coinbase_puzzlehash:
                 all_coins.append(coin)
 
-    def check_nodes_in_sync():
+    def check_nodes_in_sync() -> bool:
         p1 = full_node_2.full_node.blockchain.get_peak()
         p2 = full_node_1.full_node.blockchain.get_peak()
         return p1 == p2
@@ -2629,7 +2809,9 @@ async def test_shallow_reorg_nodes(
     await add_blocks_in_batches(chain_b[-1:], full_node_1.full_node)
 
     # make sure node 1 reorged onto chain B
-    assert full_node_1.full_node.blockchain.get_peak().header_hash == chain_b[-1].header_hash
+    peak = full_node_1.full_node.blockchain.get_peak()
+    assert peak is not None
+    assert peak.header_hash == chain_b[-1].header_hash
 
     await time_out_assert(10, check_nodes_in_sync)
     await validate_coin_set(full_node_1.full_node.blockchain.coin_store, chain_b)