chia-blockchain 2.5.7rc4__py3-none-any.whl → 2.5.8rc1__py3-none-any.whl

chia/_tests/core/full_node/test_full_node.py

@@ -5,13 +5,16 @@ import contextlib
 import dataclasses
 import logging
 import random
+import sqlite3
 import time
 from collections.abc import Awaitable, Coroutine
-from typing import Any, Optional
+from typing import Any
 
 import pytest
 from chia_rs import (
     AugSchemeMPL,
+    Coin,
+    CoinRecord,
     ConsensusConstants,
     Foliage,
     FoliageTransactionBlock,
@@ -37,6 +40,7 @@ from chia._tests.connection_utils import add_dummy_connection, connect_and_get_p
 from chia._tests.core.full_node.stores.test_coin_store import get_future_reward_coins
 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.core.test_db_validation import make_db
 from chia._tests.util.misc import wallet_height_at_least
 from chia._tests.util.setup_nodes import (
     OldSimulatorsAndWallets,
@@ -52,14 +56,14 @@ from chia.consensus.get_block_challenge import get_block_challenge
 from chia.consensus.multiprocess_validation import PreValidationResult, pre_validate_block
 from chia.consensus.pot_iterations import is_overflow_block
 from chia.consensus.signage_point import SignagePoint
-from chia.full_node.full_node import WalletUpdate
+from chia.full_node.full_node import FullNode, WalletUpdate
 from chia.full_node.full_node_api import FullNodeAPI
 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.farmer_protocol import DeclareProofOfSpace
 from chia.protocols.full_node_protocol import NewTransaction, RespondTransaction
-from chia.protocols.outbound_message import Message, NodeType
+from chia.protocols.outbound_message import Message, NodeType, make_msg
 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
@@ -91,7 +95,6 @@ from chia.types.blockchain_format.proof_of_space import (
 )
 from chia.types.blockchain_format.serialized_program import SerializedProgram
 from chia.types.blockchain_format.vdf import CompressibleVDFField, VDFProof
-from chia.types.coin_record import CoinRecord
 from chia.types.coin_spend import make_spend
 from chia.types.condition_opcodes import ConditionOpcode
 from chia.types.condition_with_args import ConditionWithArgs
@@ -102,6 +105,7 @@ from chia.util.casts import int_to_bytes
 from chia.util.errors import ConsensusError, Err
 from chia.util.hash import std_hash
 from chia.util.limited_semaphore import LimitedSemaphore
+from chia.util.path import path_from_root
 from chia.util.recursive_replace import recursive_replace
 from chia.util.task_referencer import create_referenced_task
 from chia.wallet.estimate_fees import estimate_fees
@@ -111,6 +115,13 @@ from chia.wallet.wallet_node import WalletNode
 from chia.wallet.wallet_spend_bundle import WalletSpendBundle
 
 
+def find_reward_coin(b: FullBlock, puzzle_hash: bytes32) -> Coin:
+    for c in b.get_included_reward_coins():
+        if c.puzzle_hash == puzzle_hash:
+            return c
+    raise ValueError("no reward coin with the specified puzzle hash found")
+
+
 def test_pre_validation_result() -> None:
     conds = SpendBundleConditions([], 0, 0, 0, None, None, [], 0, 0, 0, True, 0, 0, 0, 0, 0)
     results = PreValidationResult(None, uint64(1), conds, uint32(0))
@@ -246,7 +257,7 @@ async def test_block_compression(
     await time_out_assert(30, check_transaction_confirmed, True, tr)
 
     # Confirm generator is not compressed
-    program: Optional[SerializedProgram] = (await full_node_1.get_all_full_blocks())[-1].transactions_generator
+    program: SerializedProgram | None = (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
 
@@ -812,11 +823,10 @@ async def test_respond_unfinished(
         block_list_input=blocks,
         guarantee_transaction_block=True,
         farmer_reward_puzzle_hash=ph,
-        pool_reward_puzzle_hash=ph,
     )
     await full_node_1.full_node.add_block(blocks[-2])
     await full_node_1.full_node.add_block(blocks[-1])
-    coin_to_spend = blocks[-1].get_included_reward_coins()[0]
+    coin_to_spend = find_reward_coin(blocks[-1], ph)
 
     spend_bundle = wallet_a.generate_signed_transaction(coin_to_spend.amount, ph_receiver, coin_to_spend)
 
@@ -936,7 +946,6 @@ async def test_new_transaction_and_mempool(
         3,
         guarantee_transaction_block=True,
         farmer_reward_puzzle_hash=wallet_ph,
-        pool_reward_puzzle_hash=wallet_ph,
     )
     for block in blocks:
         await full_node_1.full_node.add_block(block)
@@ -993,7 +1002,7 @@ async def test_new_transaction_and_mempool(
     included_tx = 0
     not_included_tx = 0
     seen_bigger_transaction_has_high_fee = False
-    successful_bundle: Optional[WalletSpendBundle] = None
+    successful_bundle: WalletSpendBundle | None = None
 
     # Fill mempool
     receiver_puzzlehash = wallet_receiver.get_new_puzzlehash()
@@ -1127,7 +1136,6 @@ async def test_request_respond_transaction(
         block_list_input=blocks,
         guarantee_transaction_block=True,
         farmer_reward_puzzle_hash=wallet_ph,
-        pool_reward_puzzle_hash=wallet_ph,
     )
 
     incoming_queue, _dummy_node_id = await add_dummy_connection(server_1, self_hostname, 12312)
@@ -1148,9 +1156,8 @@ async def test_request_respond_transaction(
 
     receiver_puzzlehash = wallet_receiver.get_new_puzzlehash()
 
-    spend_bundle = wallet_a.generate_signed_transaction(
-        uint64(100), receiver_puzzlehash, blocks[-1].get_included_reward_coins()[0]
-    )
+    coin = find_reward_coin(blocks[-1], wallet_ph)
+    spend_bundle = wallet_a.generate_signed_transaction(uint64(100), receiver_puzzlehash, coin)
     assert spend_bundle is not None
     respond_transaction = fnp.RespondTransaction(spend_bundle)
     res = await full_node_1.respond_transaction(respond_transaction, peer)
@@ -1192,7 +1199,6 @@ async def test_respond_transaction_fail(
         block_list_input=blocks,
         guarantee_transaction_block=True,
         farmer_reward_puzzle_hash=cb_ph,
-        pool_reward_puzzle_hash=cb_ph,
     )
     await asyncio.sleep(1)
     while incoming_queue.qsize() > 0:
@@ -1204,11 +1210,8 @@ async def test_respond_transaction_fail(
 
     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(
-        uint64(100_000_000_000_000),
-        receiver_puzzlehash,
-        blocks_new[-1].get_included_reward_coins()[0],
-    )
+    coin = find_reward_coin(blocks_new[-1], cb_ph)
+    spend_bundle = wallet_a.generate_signed_transaction(uint64(100_000_000_000_000), receiver_puzzlehash, coin)
 
     assert spend_bundle is not None
     respond_transaction = fnp.RespondTransaction(spend_bundle)
@@ -1228,18 +1231,15 @@ async def test_request_block(
     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()
 
+    wallet_ph = wallet_a.get_new_puzzlehash()
     blocks = bt.get_consecutive_blocks(
         3,
         block_list_input=blocks,
         guarantee_transaction_block=True,
-        farmer_reward_puzzle_hash=wallet_a.get_new_puzzlehash(),
-        pool_reward_puzzle_hash=wallet_a.get_new_puzzlehash(),
-    )
-    spend_bundle = wallet_a.generate_signed_transaction(
-        uint64(1123),
-        wallet_receiver.get_new_puzzlehash(),
-        blocks[-1].get_included_reward_coins()[0],
+        farmer_reward_puzzle_hash=wallet_ph,
     )
+    coin = find_reward_coin(blocks[-1], wallet_ph)
+    spend_bundle = wallet_a.generate_signed_transaction(uint64(1123), wallet_receiver.get_new_puzzlehash(), coin)
     blocks = bt.get_consecutive_blocks(
         1, block_list_input=blocks, guarantee_transaction_block=True, transaction_data=spend_bundle
     )
@@ -1280,18 +1280,19 @@ async def test_request_blocks(
     blocks = await full_node_1.get_all_full_blocks()
 
     # create more blocks than constants.MAX_BLOCK_COUNT_PER_REQUEST (32)
+    wallet_ph = wallet_a.get_new_puzzlehash()
     blocks = bt.get_consecutive_blocks(
         33,
         block_list_input=blocks,
         guarantee_transaction_block=True,
-        farmer_reward_puzzle_hash=wallet_a.get_new_puzzlehash(),
-        pool_reward_puzzle_hash=wallet_a.get_new_puzzlehash(),
+        farmer_reward_puzzle_hash=wallet_ph,
     )
 
+    coin = find_reward_coin(blocks[-1], wallet_ph)
     spend_bundle = wallet_a.generate_signed_transaction(
         uint64(1123),
         wallet_receiver.get_new_puzzlehash(),
-        blocks[-1].get_included_reward_coins()[0],
+        coin,
     )
     blocks_t = bt.get_consecutive_blocks(
         1, block_list_input=blocks, guarantee_transaction_block=True, transaction_data=spend_bundle
@@ -1375,7 +1376,7 @@ async def test_new_unfinished_block(
         assert res is not None
         assert res is not None and res.data == bytes(fnp.RequestUnfinishedBlock(unf.partial_hash))
 
-    # when we receive a new unfinished block, we advertize it to our peers.
+    # when we receive a new unfinished block, we advertise it to our peers.
     # We send new_unfinished_blocks to old peers (0.0.35 and earlier) and we
     # send new_unfinishe_blocks2 to new peers (0.0.6 and later). Test both
     peer.protocol_version = Version(peer_version)
@@ -1473,7 +1474,7 @@ async def test_new_unfinished_block2_forward_limit(
 
     unf_blocks: list[UnfinishedBlock] = []
 
-    last_reward_hash: Optional[bytes32] = None
+    last_reward_hash: bytes32 | None = None
     for idx in range(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
@@ -1769,7 +1770,7 @@ async def test_request_unfinished_block2(
 
     # the "best" unfinished block according to the metric we use to pick one
     # deterministically
-    best_unf: Optional[UnfinishedBlock] = None
+    best_unf: UnfinishedBlock | None = None
 
     for idx in range(6):
         # we include a different transaction in each block. This makes the
@@ -2450,31 +2451,30 @@ async def test_invalid_capability_can_connect(
 @pytest.mark.anyio
 async def test_node_start_with_existing_blocks(db_version: int) -> None:
     with TempKeyring(populate=True) as keychain:
-        block_tools = await create_block_tools_async(keychain=keychain)
-
-        blocks_per_cycle = 5
-        expected_height = 0
-
-        for cycle in range(2):
-            async with setup_full_node(
-                consensus_constants=block_tools.constants,
-                db_name="node_restart_test.db",
-                self_hostname=block_tools.config["self_hostname"],
-                local_bt=block_tools,
-                simulator=True,
-                db_version=db_version,
-                reuse_db=True,
-            ) as service:
-                simulator_api = service._api
-                assert isinstance(simulator_api, FullNodeSimulator)
-                await simulator_api.farm_blocks_to_puzzlehash(count=blocks_per_cycle)
-
-                expected_height += blocks_per_cycle
-                assert simulator_api.full_node._blockchain is not None
-                block_record = simulator_api.full_node._blockchain.get_peak()
-
-                assert block_record is not None, f"block_record is None on cycle {cycle + 1}"
-                assert block_record.height == expected_height, f"wrong height on cycle {cycle + 1}"
+        async with create_block_tools_async(keychain=keychain) as block_tools:
+            blocks_per_cycle = 5
+            expected_height = 0
+
+            for cycle in range(2):
+                async with setup_full_node(
+                    consensus_constants=block_tools.constants,
+                    db_name="node_restart_test.db",
+                    self_hostname=block_tools.config["self_hostname"],
+                    local_bt=block_tools,
+                    simulator=True,
+                    db_version=db_version,
+                    reuse_db=True,
+                ) as service:
+                    simulator_api = service._api
+                    assert isinstance(simulator_api, FullNodeSimulator)
+                    await simulator_api.farm_blocks_to_puzzlehash(count=blocks_per_cycle)
+
+                    expected_height += blocks_per_cycle
+                    assert simulator_api.full_node._blockchain is not None
+                    block_record = simulator_api.full_node._blockchain.get_peak()
+
+                    assert block_record is not None, f"block_record is None on cycle {cycle + 1}"
+                    assert block_record.height == expected_height, f"wrong height on cycle {cycle + 1}"
 
 
 @pytest.mark.anyio
@@ -2713,7 +2713,7 @@ async def test_long_reorg_nodes(
         p2 = full_node_1.full_node.blockchain.get_peak()
         return p1 == p2
 
-    await time_out_assert(300, check_nodes_in_sync)
+    await time_out_assert(600, 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]}")
@@ -3224,12 +3224,15 @@ async def declare_pos_unfinished_block(
         include_signature_source_data=True,
     )
     await full_node_api.declare_proof_of_space(pospace, dummy_peer)
-    q_str: Optional[bytes32] = verify_and_get_quality_string(
+    tx_peak = blockchain.get_tx_peak()
+    assert tx_peak is not None
+    q_str: bytes32 | None = verify_and_get_quality_string(
         block.reward_chain_block.proof_of_space,
         blockchain.constants,
         challenge,
         challenge_chain_sp,
         height=block.reward_chain_block.height,
+        prev_transaction_block_height=tx_peak.height,
     )
     assert q_str is not None
     unfinised_block = None
@@ -3256,7 +3259,7 @@ async def add_tx_to_mempool(
     coinbase_puzzlehash: bytes32,
     receiver_puzzlehash: bytes32,
     amount: uint64,
-) -> Optional[SpendBundle]:
+) -> SpendBundle | None:
     spend_coin = None
     coins = spend_block.get_included_reward_coins()
     for coin in coins:
@@ -3322,7 +3325,9 @@ async def test_pending_tx_cache_retry_on_new_peak(
         wallet = WalletTool(test_constants)
         ph = wallet.get_new_puzzlehash()
         blocks = bt.get_consecutive_blocks(
-            3, guarantee_transaction_block=True, farmer_reward_puzzle_hash=ph, pool_reward_puzzle_hash=ph
+            3,
+            guarantee_transaction_block=True,
+            farmer_reward_puzzle_hash=ph,
         )
         for block in blocks:
             await full_node_api.full_node.add_block(block)
@@ -3330,7 +3335,7 @@ async def test_pending_tx_cache_retry_on_new_peak(
         assert peak is not None
         current_height = peak.height
         # Create a transaction with a height condition that makes it pending
-        coin = blocks[-1].get_included_reward_coins()[0]
+        coin = find_reward_coin(blocks[-1], ph)
         if condition == ConditionOpcode.ASSERT_HEIGHT_RELATIVE:
             condition_height = 1
         else:
@@ -3357,3 +3362,161 @@ async def test_pending_tx_cache_retry_on_new_peak(
         assert f"Added transaction to mempool: {sb_name}\n" in caplog.text
         # Make sure the transaction was retried and got added to the mempool
         assert full_node_api.full_node.mempool_manager.get_mempool_item(sb_name, include_pending=False) is not None
+
+
+@pytest.mark.anyio
+@pytest.mark.parametrize("mismatch_cost", [True, False])
+@pytest.mark.parametrize("mismatch_fee", [True, False])
+@pytest.mark.parametrize("tx_already_seen", [True, False])
+@pytest.mark.parametrize("mismatch_on_reannounce", [True, False])
+async def test_ban_for_mismatched_tx_cost_fee(
+    three_nodes: list[FullNodeAPI],
+    bt: BlockTools,
+    self_hostname: str,
+    mismatch_cost: bool,
+    mismatch_fee: bool,
+    tx_already_seen: bool,
+    mismatch_on_reannounce: bool,
+) -> None:
+    """
+    Tests that a peer gets banned if it sends a `NewTransaction` message with a
+    cost and/or fee that doesn't match the transaction's validation cost/fee.
+    We setup full nodes, and with `tx_already_seen` we control whether the
+    first full node has this transaction already or it needs to request it.
+    In both cases we check the transaction's validation cost and fee against
+    the ones specified in the `NewTransaction` message.
+    With `mismatch_on_reannounce` we control whether the peer sent us the same
+    transaction twice with different cost and fee.
+    """
+    full_node_1, full_node_2, full_node_3 = three_nodes
+    server_1 = full_node_1.full_node.server
+    server_2 = full_node_2.full_node.server
+    server_3 = full_node_3.full_node.server
+    await server_2.start_client(PeerInfo(self_hostname, server_1.get_port()), full_node_2.full_node.on_connect)
+    await server_3.start_client(PeerInfo(self_hostname, server_1.get_port()), full_node_3.full_node.on_connect)
+    ws_con_1 = next(iter(server_1.all_connections.values()))
+    ws_con_2 = next(iter(server_2.all_connections.values()))
+    ws_con_3 = next(iter(server_3.all_connections.values()))
+    wallet = WalletTool(test_constants)
+    wallet_ph = wallet.get_new_puzzlehash()
+    # If we're covering that the first full node has this transaction already
+    # we must add it accordingly, otherwise we'll add it to the second node so
+    # that the first node requests it, reacting to the NewTransaction message.
+    if tx_already_seen:
+        node = full_node_1.full_node
+        ws_con = ws_con_1
+    else:
+        node = full_node_2.full_node
+        ws_con = ws_con_2
+    blocks = bt.get_consecutive_blocks(3, guarantee_transaction_block=True, farmer_reward_puzzle_hash=wallet_ph)
+    for block in blocks:
+        await node.add_block(block)
+    # Create a transaction and add it to the relevant full node's mempool
+    coin = find_reward_coin(blocks[-1], wallet_ph)
+    sb = wallet.generate_signed_transaction(uint64(42), wallet_ph, coin)
+    sb_name = sb.name()
+    await node.add_transaction(sb, sb_name, ws_con)
+    mempool_item = node.mempool_manager.get_mempool_item(sb_name)
+    assert mempool_item is not None
+    # Now send a NewTransaction with a cost and/or fee mismatch from the second
+    # full node.
+    cost = uint64(mempool_item.cost + 1) if mismatch_cost else mempool_item.cost
+    fee = uint64(mempool_item.fee + 1) if mismatch_fee else mempool_item.fee
+    msg = make_msg(ProtocolMessageTypes.new_transaction, NewTransaction(mempool_item.name, cost, fee))
+    # We won't ban localhost, so let's set a different ip address for the
+    # second node.
+    full_node_2_ip = "1.3.3.7"
+    ws_con_1.peer_info = PeerInfo(full_node_2_ip, ws_con_1.peer_info.port)
+
+    # Send the NewTransaction message from the second node to the first
+    async def send_from_node_2() -> None:
+        await ws_con_2.send_message(msg)
+
+    # Send this message from the third node as well, just to end up with two
+    # peers advertising the same transaction at the same time.
+    async def send_from_node_3() -> None:
+        await ws_con_3.send_message(msg)
+
+    for node in [full_node_1.full_node, full_node_2.full_node, full_node_3.full_node]:
+        await time_out_assert(5, node.synced)
+    await asyncio.gather(send_from_node_2(), send_from_node_3())
+    if mismatch_on_reannounce and (mismatch_cost or mismatch_fee):
+        # Send a second NewTransaction that doesn't match the first
+        reannounce_cost = uint64(cost + 1) if mismatch_cost else cost
+        reannounce_fee = uint64(fee + 1) if mismatch_fee else fee
+        reannounce_msg = make_msg(
+            ProtocolMessageTypes.new_transaction, NewTransaction(mempool_item.name, reannounce_cost, reannounce_fee)
+        )
+        await ws_con_2.send_message(reannounce_msg)
+        # Make sure the peer is banned as it sent the same transaction twice
+        # with different cost and/or fee.
+        await time_out_assert(5, lambda: full_node_2_ip in server_1.banned_peers)
+        return
+    if not tx_already_seen:
+        # When the first full node receives the NewTransaction message and it
+        # hasn't seen the transaction before, it will issue a transaction
+        # request. We need to wait until it receives the transaction and add it
+        # to its mempool.
+        await time_out_assert(30, lambda: full_node_1.full_node.mempool_manager.seen(mempool_item.name))
+    # Make sure the first full node has banned the second as the item it has
+    # already seen has a different validation cost and/or fee than the one from
+    # the NewTransaction message.
+    if mismatch_cost or mismatch_fee:
+        await time_out_assert(5, lambda: full_node_2_ip in server_1.banned_peers)
+    else:
+        await time_out_assert(5, lambda: full_node_2_ip not in server_1.banned_peers)
+
+
+@pytest.mark.anyio
+async def test_new_tx_zero_cost(
+    setup_two_nodes_fixture: tuple[list[FullNodeSimulator], list[tuple[WalletNode, ChiaServer]], BlockTools],
+    self_hostname: str,
+) -> None:
+    """
+    Tests that a peer gets banned if it sends a `NewTransaction` message with
+    zero cost.
+    """
+    [full_node_1, full_node_2], _, bt = setup_two_nodes_fixture
+    server_1 = full_node_1.full_node.server
+    server_2 = full_node_2.full_node.server
+    await server_2.start_client(PeerInfo(self_hostname, server_1.get_port()), full_node_2.full_node.on_connect)
+    ws_con_1 = next(iter(server_1.all_connections.values()))
+    ws_con_2 = next(iter(server_2.all_connections.values()))
+    await full_node_1.full_node.add_block(bt.get_consecutive_blocks(1)[0])
+    # Send a NewTransaction with zero cost
+    msg = make_msg(
+        ProtocolMessageTypes.new_transaction, NewTransaction(bytes32.random(), cost=uint64(0), fees=uint64(42))
+    )
+    # We won't ban localhost, so let's set a different ip address for the
+    # second node.
+    full_node_2_ip = "1.3.3.7"
+    ws_con_1.peer_info = PeerInfo(full_node_2_ip, ws_con_1.peer_info.port)
+    await ws_con_2.send_message(msg)
+    # Make sure the first full node has banned the second.
+    await time_out_assert(3, lambda: full_node_2_ip in server_1.banned_peers)
+
+
+@pytest.mark.anyio
+@pytest.mark.limit_consensus_modes(allowed=[ConsensusMode.HARD_FORK_2_0], reason="save time")
+async def test_corrupt_blockchain(bt: BlockTools, default_400_blocks: list[FullBlock]) -> None:
+    full_node = await FullNode.create(
+        bt.config["full_node"],
+        root_path=bt.root_path,
+        consensus_constants=bt.constants,
+    )
+
+    config = bt.config["full_node"]
+    db_path_replaced: str = config["database_path"].replace("CHALLENGE", config["selected_network"])
+    db_path = path_from_root(bt.root_path, db_path_replaced)
+    db_path.parent.mkdir(parents=True, exist_ok=True)
+
+    await make_db(db_path, default_400_blocks)
+    with contextlib.closing(sqlite3.connect(db_path)) as conn:
+        conn.execute("DELETE FROM current_peak;")
+        conn.commit()
+
+    with pytest.raises(RuntimeError, match="corrupt blockchain DB"):
+        # the blockchain is empty (without a peak)
+        # but there are coins in the coin store
+        async with full_node.manage():
+            pass  # pragma: no cover

chia/_tests/core/full_node/test_hint_management.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Optional
-
 import pytest
 from chia_rs import BlockRecord
 from chia_rs.sized_bytes import bytes32
@@ -38,7 +36,7 @@ async def test_hints_to_add(bt: BlockTools, empty_blockchain: Blockchain) -> Non
     blocks = bt.get_consecutive_blocks(2)
     await _validate_and_add_block(empty_blockchain, blocks[0])
     await _validate_and_add_block(empty_blockchain, blocks[1])
-    br: Optional[BlockRecord] = empty_blockchain.get_peak()
+    br: BlockRecord | None = empty_blockchain.get_peak()
     assert br is not None
 
     scs = StateChangeSummary(br, uint32(0), [], removals, additions, [])
@@ -56,7 +54,7 @@ async def test_lookup_coin_ids(bt: BlockTools, empty_blockchain: Blockchain) ->
     blocks = bt.get_consecutive_blocks(2)
     await _validate_and_add_block(empty_blockchain, blocks[0])
     await _validate_and_add_block(empty_blockchain, blocks[1])
-    br: Optional[BlockRecord] = empty_blockchain.get_peak()
+    br: BlockRecord | None = empty_blockchain.get_peak()
     assert br is not None
 
     rewards: list[Coin] = [

chia/_tests/core/full_node/test_performance.py

@@ -36,7 +36,6 @@ class TestPerformance:
             block_list_input=blocks,
             guarantee_transaction_block=True,
             farmer_reward_puzzle_hash=wallet_ph,
-            pool_reward_puzzle_hash=wallet_ph,
         )
         for block in blocks:
             await full_node_1.full_node.add_block(block)

chia/_tests/core/full_node/test_prev_tx_block.py

@@ -1,16 +1,29 @@
 from __future__ import annotations
 
-from chia_rs.sized_ints import uint32
+from chia_rs import FullBlock
+from chia_rs.sized_ints import uint8, uint32
 
-from chia.consensus.generator_tools import get_block_header
-from chia.consensus.get_block_challenge import prev_tx_block
-from chia.simulator.block_tools import BlockTools, load_block_list
+from chia.consensus.get_block_challenge import pre_sp_tx_block_height
+from chia.simulator.block_tools import BlockTools, load_block_list, test_constants
 from chia.util.block_cache import BlockCache
 
 
 def test_prev_tx_block_none() -> None:
     # If prev_b is None, should return 0
-    assert prev_tx_block(BlockCache({}), None) == uint32(0)
+    assert pre_sp_tx_block_height(
+        constants=test_constants,
+        blocks=BlockCache({}),
+        prev_b_hash=test_constants.GENESIS_CHALLENGE,
+        sp_index=uint8(0),
+        first_in_sub_slot=False,
+    ) == uint32(0)
+    assert pre_sp_tx_block_height(
+        constants=test_constants,
+        blocks=BlockCache({}),
+        prev_b_hash=test_constants.GENESIS_CHALLENGE,
+        sp_index=uint8(1),
+        first_in_sub_slot=True,
+    ) == uint32(0)
 
 
 def test_prev_tx_block_blockrecord_tx(bt: BlockTools) -> None:
@@ -21,9 +34,45 @@ def test_prev_tx_block_blockrecord_tx(bt: BlockTools) -> None:
         guarantee_transaction_block=True,
     )
     _, _, blocks = load_block_list(block_list, bt.constants)
-    assert prev_tx_block(BlockCache(blocks), block_list[-1]) == uint32(9)
-    assert prev_tx_block(BlockCache(blocks), blocks[block_list[-1].header_hash]) == uint32(9)
-    assert prev_tx_block(BlockCache(blocks), get_block_header(block_list[-1])) == uint32(9)
+    block = block_list[-1]
+    latest_tx_before_sp = find_tx_before_sp(block_list)
+    assert latest_tx_before_sp is not None
+    assert (
+        pre_sp_tx_block_height(
+            constants=test_constants,
+            blocks=BlockCache(blocks),
+            prev_b_hash=block.prev_header_hash,
+            sp_index=block.reward_chain_block.signage_point_index,
+            first_in_sub_slot=len(block.finished_sub_slots) > 0,
+        )
+        == latest_tx_before_sp.height
+    )
+    block = block_list[-2]
+    latest_tx_before_sp = find_tx_before_sp(block_list[:-1])
+    assert latest_tx_before_sp is not None
+    assert (
+        pre_sp_tx_block_height(
+            constants=test_constants,
+            blocks=BlockCache(blocks),
+            prev_b_hash=block.prev_header_hash,
+            sp_index=block.reward_chain_block.signage_point_index,
+            first_in_sub_slot=len(block.finished_sub_slots) > 0,
+        )
+        == latest_tx_before_sp.height
+    )
+    block = block_list[-3]
+    latest_tx_before_sp = find_tx_before_sp(block_list[:-2])
+    assert latest_tx_before_sp is not None
+    assert (
+        pre_sp_tx_block_height(
+            constants=test_constants,
+            blocks=BlockCache(blocks),
+            prev_b_hash=block.prev_header_hash,
+            sp_index=block.reward_chain_block.signage_point_index,
+            first_in_sub_slot=len(block.finished_sub_slots) > 0,
+        )
+        == latest_tx_before_sp.height
+    )
 
 
 def test_prev_tx_block_blockrecord_not_tx(bt: BlockTools) -> None:
@@ -38,6 +87,34 @@ def test_prev_tx_block_blockrecord_not_tx(bt: BlockTools) -> None:
         block_list_input=block_list,
     )
     _, _, blocks = load_block_list(block_list, bt.constants)
-    assert prev_tx_block(BlockCache(blocks), block_list[-1]) == uint32(7)
-    assert prev_tx_block(BlockCache(blocks), blocks[block_list[-1].header_hash]) == uint32(7)
-    assert prev_tx_block(BlockCache(blocks), get_block_header(block_list[-1])) == uint32(7)
+    block = block_list[-1]
+    latest_tx_before_sp = find_tx_before_sp(block_list)
+    assert latest_tx_before_sp is not None
+    assert pre_sp_tx_block_height(
+        constants=test_constants,
+        blocks=BlockCache(blocks),
+        prev_b_hash=block.prev_header_hash,
+        sp_index=block.reward_chain_block.signage_point_index,
+        first_in_sub_slot=len(block.finished_sub_slots) > 0,
+    ) == uint32(latest_tx_before_sp.height)
+
+
+# get the latest infused transaction block before the signage point of the last block in the list
+def find_tx_before_sp(block_list: list[FullBlock]) -> FullBlock | None:
+    before_slot = False
+    before_sp = False
+    if len(block_list[-1].finished_sub_slots) > 0:
+        before_slot = True
+    sp_index = block_list[-1].reward_chain_block.signage_point_index
+    idx = len(block_list) - 2
+    curr = None
+    while idx > 0:
+        curr = block_list[idx]
+        if curr.reward_chain_block.signage_point_index < sp_index:
+            before_sp = True
+        if curr.foliage_transaction_block is not None and (before_slot or before_sp):
+            break
+        if len(curr.finished_sub_slots) > 0:
+            before_slot = True
+        idx -= 1
+    return curr

chia/_tests/core/full_node/test_transactions.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import asyncio
 import random
-from typing import Optional
 
 import pytest
 from chia_rs import BlockRecord
@@ -77,7 +76,7 @@ async def test_tx_propagation(three_nodes_two_wallets, self_hostname, seeded_ran
     await time_out_assert(20, wallet_0.wallet_state_manager.main_wallet.get_confirmed_balance, funds)
 
     async def peak_height(fna: FullNodeAPI):
-        peak: Optional[BlockRecord] = fna.full_node.blockchain.get_peak()
+        peak: BlockRecord | None = fna.full_node.blockchain.get_peak()
         if peak is None:
             return -1
         peak_height = peak.height