chia-blockchain 2.5.7rc4__py3-none-any.whl → 2.6.0rc2__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,
@@ -33,10 +36,11 @@ from packaging.version import Version
 
 from chia._tests.blockchain.blockchain_test_utils import _validate_and_add_block, _validate_and_add_block_no_error
 from chia._tests.conftest import ConsensusMode
-from chia._tests.connection_utils import add_dummy_connection, connect_and_get_peer
+from chia._tests.connection_utils import add_dummy_connection, add_dummy_connection_wsc, connect_and_get_peer
 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()
@@ -1023,7 +1032,7 @@ async def test_new_transaction_and_mempool(
         assert estimate_fees(spend_bundle) == fee
         respond_transaction = wallet_protocol.SendTransaction(spend_bundle)
 
-        await full_node_1.send_transaction(respond_transaction)
+        await full_node_1.send_transaction(respond_transaction, fake_peer)
 
         request = fnp.RequestTransaction(spend_bundle.get_hash())
         req = await full_node_1.request_transaction(request)
@@ -1074,7 +1083,7 @@ async def test_new_transaction_and_mempool(
     assert err is None
 
     # Resubmission through wallet is also fine
-    response_msg = await full_node_1.send_transaction(SendTransaction(successful_bundle), test=True)
+    response_msg = await full_node_1.send_transaction(SendTransaction(successful_bundle), fake_peer, test=True)
     assert response_msg is not None
     assert TransactionAck.from_bytes(response_msg.data).status == MempoolInclusionStatus.SUCCESS.value
 
@@ -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]}")
@@ -2950,7 +2950,13 @@ async def test_declare_proof_of_space_no_overflow(
         assert full_node_api.full_node.blockchain.get_peak_height() == blocks[-1].height
         for i in range(10, 100):
             sb = await add_tx_to_mempool(
-                full_node_api, wallet, blocks[-8], coinbase_puzzlehash, bytes32(i.to_bytes(32, "big")), uint64(i)
+                full_node_api,
+                dummy_peer,
+                wallet,
+                blocks[-8],
+                coinbase_puzzlehash,
+                bytes32(i.to_bytes(32, "big")),
+                uint64(i),
             )
             blocks = bt.get_consecutive_blocks(
                 block_list_input=blocks,
@@ -2994,7 +3000,13 @@ async def test_declare_proof_of_space_overflow(
         assert full_node_api.full_node.blockchain.get_peak_height() == blocks[-1].height
         for i in range(10, 100):
             sb = await add_tx_to_mempool(
-                full_node_api, wallet, blocks[-8], coinbase_puzzlehash, bytes32(i.to_bytes(32, "big")), uint64(i)
+                full_node_api,
+                dummy_peer,
+                wallet,
+                blocks[-8],
+                coinbase_puzzlehash,
+                bytes32(i.to_bytes(32, "big")),
+                uint64(i),
             )
 
             blocks = bt.get_consecutive_blocks(
@@ -3224,12 +3236,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
@@ -3251,12 +3266,13 @@ async def declare_pos_unfinished_block(
 
 async def add_tx_to_mempool(
     full_node_api: FullNodeAPI,
+    dummy_peer: WSChiaConnection,
     wallet: WalletTool,
     spend_block: FullBlock,
     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:
@@ -3266,7 +3282,7 @@ async def add_tx_to_mempool(
     assert spend_coin is not None
     spend_bundle = wallet.generate_signed_transaction(amount, receiver_puzzlehash, spend_coin)
     assert spend_bundle is not None
-    response_msg = await full_node_api.send_transaction(wallet_protocol.SendTransaction(spend_bundle))
+    response_msg = await full_node_api.send_transaction(wallet_protocol.SendTransaction(spend_bundle), dummy_peer)
     assert (
         response_msg is not None
         and TransactionAck.from_bytes(response_msg.data).status == MempoolInclusionStatus.SUCCESS.value
@@ -3309,7 +3325,11 @@ def compare_unfinished_blocks(block1: UnfinishedBlock, block2: UnfinishedBlock)
     ],
 )
 async def test_pending_tx_cache_retry_on_new_peak(
-    condition: ConditionOpcode, error: str, blockchain_constants: ConsensusConstants, caplog: pytest.LogCaptureFixture
+    condition: ConditionOpcode,
+    error: str,
+    blockchain_constants: ConsensusConstants,
+    caplog: pytest.LogCaptureFixture,
+    self_hostname: str,
 ) -> None:
     """
     Covers PendingTXCache items that are placed there due to unmet relative or
@@ -3322,7 +3342,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 +3352,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:
@@ -3339,7 +3361,9 @@ async def test_pending_tx_cache_retry_on_new_peak(
         sb = wallet.generate_signed_transaction(uint64(42), ph, coin, condition_dic)
         sb_name = sb.name()
         # Send the transaction
-        res = await full_node_api.send_transaction(SendTransaction(sb))
+        _, dummy_node_id = await add_dummy_connection(full_node_api.server, self_hostname, 12312)
+        dummy_peer = full_node_api.server.all_connections[dummy_node_id]
+        res = await full_node_api.send_transaction(SendTransaction(sb), dummy_peer)
         assert res is not None
         assert ProtocolMessageTypes(res.type) == ProtocolMessageTypes.transaction_ack
         transaction_ack = TransactionAck.from_bytes(res.data)
@@ -3357,3 +3381,182 @@ 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
+
+
+@pytest.mark.anyio
+async def test_send_transaction_peer_tx_queue_full(
+    one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], self_hostname: str
+) -> None:
+    """
+    Covers the case where a peer's transaction queue is full and it sends a
+    `SendTransaction` message. The full node should send the proper
+    `TransactionAck` response with a correct error.
+    """
+    full_node_api, server, _ = one_node_one_block
+    # Set limit to 0 to trigger queue full exception
+    full_node_api.full_node.transaction_queue.peer_size_limit = 0
+    spend_bundle = SpendBundle([], G2Element())
+    dummy_peer, _ = await add_dummy_connection_wsc(server, self_hostname, 1337, NodeType.WALLET)
+    response_msg = await full_node_api.send_transaction(wallet_protocol.SendTransaction(spend_bundle), dummy_peer)
+    assert response_msg is not None
+    response = wallet_protocol.TransactionAck.from_bytes(response_msg.data)
+    assert MempoolInclusionStatus(response.status) == MempoolInclusionStatus.FAILED
+    assert response.error == "Transaction queue full"