chia-blockchain 2.5.7rc4__py3-none-any.whl → 2.6.0rc2__py3-none-any.whl

chia/_tests/core/full_node/test_hard_fork_utils.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+import pytest
+from chia_rs import BlockRecord, get_flags_for_height_and_constants
+from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint32
+
+from chia.consensus.get_block_challenge import pre_sp_tx_block_height
+from chia.full_node.hard_fork_utils import get_flags
+from chia.simulator.block_tools import BlockTools, load_block_list, test_constants
+from chia.util.block_cache import BlockCache
+
+
+class MockBlocksProtocol(BlockCache):
+    """Mock implementation of BlocksProtocol for testing get_flags."""
+
+    async def get_block_record_from_db(self, header_hash: bytes32) -> BlockRecord | None:
+        return self.try_block_record(header_hash)
+
+    async def lookup_block_generators(self, header_hash: bytes32, generator_refs: set[uint32]) -> dict[uint32, bytes]:
+        return {}
+
+    def add_block_record(self, block_record: BlockRecord) -> None:
+        self.add_block(block_record)
+
+
+@pytest.mark.anyio
+async def test_get_flags_outside_transition_period(bt: BlockTools) -> None:
+    """Test get_flags when block is outside the transition period."""
+    block_list = bt.get_consecutive_blocks(
+        10,
+        block_list_input=[],
+        guarantee_transaction_block=True,
+    )
+    _, _, blocks = load_block_list(block_list, bt.constants)
+    block = block_list[-1]
+    mock_blocks = MockBlocksProtocol(blocks)
+
+    # Before hard fork: block.height < HARD_FORK2_HEIGHT, expects 0
+    constants = test_constants.replace(HARD_FORK2_HEIGHT=uint32(1000))
+    assert block.height < constants.HARD_FORK2_HEIGHT
+    result = await get_flags(constants, mock_blocks, block)
+    assert result == 0
+
+    # After transition period: block.height >= HARD_FORK2_HEIGHT + SUB_EPOCH_BLOCKS
+    constants = test_constants.replace(
+        HARD_FORK2_HEIGHT=uint32(0),
+        SUB_EPOCH_BLOCKS=uint32(min(5, block.height)),
+    )
+    assert block.height >= constants.HARD_FORK2_HEIGHT + constants.SUB_EPOCH_BLOCKS
+    result = await get_flags(constants, mock_blocks, block)
+    assert result == get_flags_for_height_and_constants(block.height, constants)
+
+
+@pytest.mark.anyio
+async def test_get_flags_during_transition_period(bt: BlockTools) -> None:
+    """When block.height is in the transition period, get_flags should walk
+    the chain and return flags based on the latest tx block before signage point."""
+    # We need more blocks to ensure we're in the transition period
+    block_list = bt.get_consecutive_blocks(
+        15,
+        block_list_input=[],
+        guarantee_transaction_block=True,
+    )
+    _, _, blocks = load_block_list(block_list, bt.constants)
+    mock_blocks = MockBlocksProtocol(blocks)
+
+    # Configure constants so that the block is in the transition period
+    # HARD_FORK2_HEIGHT <= block.height < HARD_FORK2_HEIGHT + SUB_EPOCH_BLOCKS
+    block = block_list[-1]
+    # Set HARD_FORK2_HEIGHT to be close to block height but leave room for transition
+    constants = test_constants.replace(
+        HARD_FORK2_HEIGHT=uint32(max(0, block.height - 5)),
+        SUB_EPOCH_BLOCKS=test_constants.SUB_EPOCH_BLOCKS,
+    )
+
+    # Ensure we're in the transition period
+    assert block.height >= constants.HARD_FORK2_HEIGHT
+    assert block.height < constants.HARD_FORK2_HEIGHT + constants.SUB_EPOCH_BLOCKS
+
+    result = await get_flags(constants, mock_blocks, block)
+
+    # The result should be based on the height of the latest tx block before the signage point
+    expected_height = pre_sp_tx_block_height(
+        constants=constants,
+        blocks=mock_blocks,
+        prev_b_hash=block.prev_header_hash,
+        sp_index=block.reward_chain_block.signage_point_index,
+        finished_sub_slots=len(block.finished_sub_slots),
+    )
+    expected = get_flags_for_height_and_constants(expected_height, constants)
+    assert result == expected

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),
+        finished_sub_slots=0,
+    ) == uint32(0)
+    assert pre_sp_tx_block_height(
+        constants=test_constants,
+        blocks=BlockCache({}),
+        prev_b_hash=test_constants.GENESIS_CHALLENGE,
+        sp_index=uint8(1),
+        finished_sub_slots=1,
+    ) == 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,
+            finished_sub_slots=len(block.finished_sub_slots),
+        )
+        == 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,
+            finished_sub_slots=len(block.finished_sub_slots),
+        )
+        == 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,
+            finished_sub_slots=len(block.finished_sub_slots),
+        )
+        == 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,
+        finished_sub_slots=len(block.finished_sub_slots),
+    ) == 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

chia/_tests/core/full_node/test_tx_processing_queue.py

@@ -2,35 +2,46 @@ from __future__ import annotations
 
 import asyncio
 import logging
+import math
 import random
-from dataclasses import dataclass
-from typing import Optional, cast
+from dataclasses import dataclass, field
+from typing import cast
 
 import pytest
+from chia_rs import G2Element, SpendBundle
 from chia_rs.sized_bytes import bytes32
+from chia_rs.sized_ints import uint64
 
-from chia.full_node.tx_processing_queue import TransactionQueue, TransactionQueueEntry, TransactionQueueFull
+from chia.full_node.tx_processing_queue import PeerWithTx, TransactionQueue, TransactionQueueEntry, TransactionQueueFull
+from chia.simulator.block_tools import test_constants
 from chia.util.task_referencer import create_referenced_task
 
 log = logging.getLogger(__name__)
 
+TEST_MAX_TX_CLVM_COST = uint64(test_constants.MAX_BLOCK_COST_CLVM // 2)
+
 
 @dataclass(frozen=True)
 class FakeTransactionQueueEntry:
-    index: int
-    peer_id: Optional[bytes32]
+    index: int = field(compare=False)
+    peer_id: bytes32 | None = field(compare=False)
+    peers_with_tx: dict[bytes32, PeerWithTx] | None = field(compare=False)
 
 
-def get_transaction_queue_entry(peer_id: Optional[bytes32], tx_index: int) -> TransactionQueueEntry:  # easy shortcut
-    return cast(TransactionQueueEntry, FakeTransactionQueueEntry(index=tx_index, peer_id=peer_id))
+def get_transaction_queue_entry(
+    peer_id: bytes32 | None, tx_index: int, peers_with_tx: dict[bytes32, PeerWithTx] | None = None
+) -> TransactionQueueEntry:  # easy shortcut
+    if peers_with_tx is None:
+        peers_with_tx = {}
+    return cast(TransactionQueueEntry, FakeTransactionQueueEntry(tx_index, peer_id, peers_with_tx))
 
 
 @pytest.mark.anyio
 async def test_local_txs(seeded_random: random.Random) -> None:
-    transaction_queue = TransactionQueue(1000, log)
+    transaction_queue = TransactionQueue(1000, log, max_tx_clvm_cost=TEST_MAX_TX_CLVM_COST)
     # test 1 tx
     first_tx = get_transaction_queue_entry(None, 0)
-    await transaction_queue.put(first_tx, None)
+    transaction_queue.put(first_tx, None)
 
     result1 = await transaction_queue.pop()
 
@@ -40,7 +51,7 @@ async def test_local_txs(seeded_random: random.Random) -> None:
     num_txs = 2000
     list_txs = [get_transaction_queue_entry(bytes32.random(seeded_random), i) for i in range(num_txs)]
     for tx in list_txs:
-        await transaction_queue.put(tx, None)
+        transaction_queue.put(tx, None)
 
     resulting_txs = []
     for _ in range(num_txs):
@@ -52,18 +63,18 @@ async def test_local_txs(seeded_random: random.Random) -> None:
 
 @pytest.mark.anyio
 async def test_one_peer_and_await(seeded_random: random.Random) -> None:
-    transaction_queue = TransactionQueue(1000, log)
+    transaction_queue = TransactionQueue(1000, log, max_tx_clvm_cost=TEST_MAX_TX_CLVM_COST)
     num_txs = 100
     peer_id = bytes32.random(seeded_random)
 
     list_txs = [get_transaction_queue_entry(peer_id, i) for i in range(num_txs)]
     for tx in list_txs:
-        await transaction_queue.put(tx, peer_id)
+        transaction_queue.put(tx, peer_id)
 
     # test transaction priority
     local_txs = [get_transaction_queue_entry(None, i) for i in range(int(num_txs / 5))]  # 20 txs
     for tx in local_txs:
-        await transaction_queue.put(tx, None)
+        transaction_queue.put(tx, None)
 
     resulting_txs = []
     for _ in range(num_txs + len(local_txs)):
@@ -80,13 +91,13 @@ async def test_one_peer_and_await(seeded_random: random.Random) -> None:
     with pytest.raises(asyncio.InvalidStateError):  # task is not done, so we expect an error when getting result
         task.result()
     # add a tx to test task completion
-    await transaction_queue.put(get_transaction_queue_entry(None, 0), None)
+    transaction_queue.put(get_transaction_queue_entry(None, 0), None)
     await asyncio.wait_for(task, 1)  # we should never time out here
 
 
 @pytest.mark.anyio
 async def test_lots_of_peers(seeded_random: random.Random) -> None:
-    transaction_queue = TransactionQueue(1000, log)
+    transaction_queue = TransactionQueue(1000, log, max_tx_clvm_cost=TEST_MAX_TX_CLVM_COST)
     num_peers = 1000
     num_txs = 100
     total_txs = num_txs * num_peers
@@ -95,7 +106,7 @@ async def test_lots_of_peers(seeded_random: random.Random) -> None:
     # 100 txs per peer
     list_txs = [get_transaction_queue_entry(peer_id, i) for peer_id in peer_ids for i in range(num_txs)]
     for tx in list_txs:
-        await transaction_queue.put(tx, tx.peer_id)  # type: ignore[attr-defined]
+        transaction_queue.put(tx, tx.peer_id)  # type: ignore[attr-defined]
 
     resulting_txs = []
     for _ in range(total_txs):
@@ -108,7 +119,7 @@ async def test_lots_of_peers(seeded_random: random.Random) -> None:
 
 @pytest.mark.anyio
 async def test_full_queue(seeded_random: random.Random) -> None:
-    transaction_queue = TransactionQueue(1000, log)
+    transaction_queue = TransactionQueue(1000, log, max_tx_clvm_cost=TEST_MAX_TX_CLVM_COST)
     num_peers = 100
     num_txs = 1000
     total_txs = num_txs * num_peers
@@ -117,11 +128,11 @@ async def test_full_queue(seeded_random: random.Random) -> None:
     # 999 txs per peer then 1 to fail later
     list_txs = [get_transaction_queue_entry(peer_id, i) for peer_id in peer_ids for i in range(num_txs)]
     for tx in list_txs:
-        await transaction_queue.put(tx, tx.peer_id)  # type: ignore[attr-defined]
+        transaction_queue.put(tx, tx.peer_id)  # type: ignore[attr-defined]
 
     # test failure case.
     with pytest.raises(TransactionQueueFull):
-        await transaction_queue.put(get_transaction_queue_entry(peer_ids[0], 1001), peer_ids[0])
+        transaction_queue.put(get_transaction_queue_entry(peer_ids[0], 1001), peer_ids[0])
 
     resulting_txs = []
     for _ in range(total_txs):
@@ -130,25 +141,182 @@ async def test_full_queue(seeded_random: random.Random) -> None:
 
 @pytest.mark.anyio
 async def test_queue_cleanup_and_fairness(seeded_random: random.Random) -> None:
-    transaction_queue = TransactionQueue(1000, log)
+    transaction_queue = TransactionQueue(1000, log, max_tx_clvm_cost=TEST_MAX_TX_CLVM_COST)
     peer_a = bytes32.random(seeded_random)
     peer_b = bytes32.random(seeded_random)
     peer_c = bytes32.random(seeded_random)
 
+    higher_tx_cost = uint64(20)
+    lower_tx_cost = uint64(10)
+    higher_tx_fee = uint64(5)
+    lower_tx_fee = uint64(1)
     # 2 for a, 1 for b, 2 for c
-    peer_tx_a = [get_transaction_queue_entry(peer_a, i) for i in range(2)]
-    peer_tx_b = [get_transaction_queue_entry(peer_b, 0)]
-    peer_tx_c = [get_transaction_queue_entry(peer_c, i) for i in range(2)]
+    peer_tx_a = [
+        get_transaction_queue_entry(peer_a, 0, {peer_a: PeerWithTx(str(peer_a), lower_tx_fee, higher_tx_cost)}),
+        get_transaction_queue_entry(peer_a, 1, {peer_a: PeerWithTx(str(peer_a), higher_tx_fee, lower_tx_cost)}),
+    ]
+    peer_tx_b = [
+        get_transaction_queue_entry(peer_b, 0, {peer_b: PeerWithTx(str(peer_b), higher_tx_fee, lower_tx_cost)})
+    ]
+    peer_tx_c = [
+        get_transaction_queue_entry(peer_c, 0, {peer_c: PeerWithTx(str(peer_c), higher_tx_fee, lower_tx_cost)}),
+        get_transaction_queue_entry(peer_c, 1, {peer_c: PeerWithTx(str(peer_c), lower_tx_fee, higher_tx_cost)}),
+    ]
 
     list_txs = peer_tx_a + peer_tx_b + peer_tx_c
     for tx in list_txs:
-        await transaction_queue.put(tx, tx.peer_id)  # type: ignore[attr-defined]
+        transaction_queue.put(tx, tx.peer_id)  # type: ignore[attr-defined]
 
-    resulting_ids = []
+    entries = []
     for _ in range(3):  # we validate we get one transaction per peer
-        resulting_ids.append((await transaction_queue.pop()).peer_id)  # type: ignore[attr-defined]
-    assert [peer_a, peer_b, peer_c] == resulting_ids  # all peers have been properly included in the queue.
-    second_resulting_ids = []
+        entry = await transaction_queue.pop()
+        entries.append((entry.peer_id, entry.index))  # type: ignore[attr-defined]
+    assert [(peer_a, 1), (peer_b, 0), (peer_c, 0)] == entries  # all peers have been properly included in the queue.
+    second_entries = []
     for _ in range(2):  # we validate that we properly queue the last 2 transactions
-        second_resulting_ids.append((await transaction_queue.pop()).peer_id)  # type: ignore[attr-defined]
-    assert [peer_a, peer_c] == second_resulting_ids
+        entry = await transaction_queue.pop()
+        second_entries.append((entry.peer_id, entry.index))  # type: ignore[attr-defined]
+    assert [(peer_a, 0), (peer_c, 1)] == second_entries
+
+
+def test_tx_queue_entry_order_compare() -> None:
+    """
+    Tests that `TransactionQueueEntry` orders and compares using transaction
+    IDs regardless of other fields.
+    """
+    # Let's create two items with the same transaction ID but different data
+    sb = SpendBundle([], G2Element())
+    sb_name = sb.name()
+    item1 = TransactionQueueEntry(
+        transaction=sb, transaction_bytes=bytes(sb), spend_name=sb_name, peer=None, test=False, peers_with_tx={}
+    )
+    item2 = TransactionQueueEntry(
+        transaction=sb, transaction_bytes=None, spend_name=sb_name, peer=None, test=True, peers_with_tx={}
+    )
+    # They should be ordered and compared (considered equal) by `spend_name`
+    # regardless of other fields.
+    assert (item1 < item2) is False
+    assert item1 == item2
+
+
+@pytest.mark.anyio
+async def test_peer_queue_prioritization_fallback() -> None:
+    """
+    Tests prioritization fallback, when `peer_id` is not in `peers_with_tx`.
+    """
+    queue = TransactionQueue(42, log, max_tx_clvm_cost=TEST_MAX_TX_CLVM_COST)
+    peer1 = bytes32.random()
+    peer2 = bytes32.random()
+    # We'll be using this peer to test the fallback, so we don't include it in
+    # peers with transactions maps.
+    peer3 = bytes32.random()
+    peers_with_tx1 = {
+        # This has FPC of 5.0
+        peer1: PeerWithTx(str(peer1), uint64(10), uint64(2)),
+        # This has FPC of 2.0 but higher advertised cost
+        peer2: PeerWithTx(str(peer2), uint64(20), uint64(10)),
+    }
+    tx1 = get_transaction_queue_entry(peer3, 0, peers_with_tx1)
+    queue.put(tx1, peer3)
+    peers_with_tx2 = {
+        # This has FPC of 3.0
+        peer1: PeerWithTx(str(peer1), uint64(30), uint64(10)),
+        # This has FPC of 4.0 but lower advertised cost
+        peer2: PeerWithTx(str(peer2), uint64(20), uint64(5)),
+        # This has FPC of 1.0 but lower advertised cost
+        peer3: PeerWithTx(str(peer3), uint64(4), uint64(4)),
+    }
+    tx2 = get_transaction_queue_entry(peer3, 1, peers_with_tx2)
+    queue.put(tx2, peer3)
+    # tx2 gets top priority with FPC 1.0
+    assert math.isclose(queue._peers_transactions_queues[peer3].priority_queue.queue[0][0], -1.0)
+    entry = await queue.pop()
+    # NOTE: This whole test file uses `index` as an addition to
+    # `TransactionQueueEntry` for easier testing, hence this type ignore here
+    # and everywhere else.
+    assert entry.index == 1  # type: ignore[attr-defined]
+    # tx1 comes next due to lowest priority fallback
+    assert math.isinf(queue._peers_transactions_queues[peer3].priority_queue.queue[0][0])
+    entry = await queue.pop()
+    assert entry.index == 0  # type: ignore[attr-defined]
+
+
+@pytest.mark.anyio
+async def test_normal_queue_deficit_round_robin() -> None:
+    """
+    Covers the deficit round robin behavior of the normal transaction queue where
+    we cycle through peers and pick their top transactions when their deficit
+    counters allow them to afford it, and we ensure that their deficit counters
+    adapt accordingly.
+    This also covers the case where a peer's top transaction does not advertise
+    cost, so that falls back to `max_tx_clvm_cost`.
+    This also covers the cleanup behavior where peers with no remaining
+    transactions are removed periodically (each 100 pop) from the queue.
+    """
+    test_max_tx_clvm_cost = uint64(20)
+    queue = TransactionQueue(42, log, max_tx_clvm_cost=test_max_tx_clvm_cost)
+    peer1 = bytes32.random()
+    peer2 = bytes32.random()
+    peer3 = bytes32.random()
+    peer4 = bytes32.random()
+    test_fee = uint64(42)
+    # We give this one the highest cost
+    tx1 = get_transaction_queue_entry(peer1, 0, {peer1: PeerWithTx(str(peer1), test_fee, uint64(15))})
+    queue.put(tx1, peer1)
+    # And this one the lowest cost
+    tx2 = get_transaction_queue_entry(peer2, 1, {peer2: PeerWithTx(str(peer2), test_fee, uint64(5))})
+    queue.put(tx2, peer2)
+    # And this one a cost in between
+    tx3 = get_transaction_queue_entry(peer3, 2, {peer3: PeerWithTx(str(peer3), test_fee, uint64(10))})
+    queue.put(tx3, peer3)
+    # This one has no cost information so its top transaction's advertised cost
+    # falls back to `test_max_tx_clvm_cost`.
+    tx4 = get_transaction_queue_entry(peer4, 3, {})
+    queue.put(tx4, peer4)
+    # When we try to pop a transaction, none of the peers initially can
+    # afford to send their top transactions, so we add the lowest cost among
+    # transactions (5) to all the peers' deficit counters and try again. This
+    # makes peer2 able to send its transaction tx2.
+    entry = await queue.pop()
+    assert entry.index == 1  # type: ignore[attr-defined]
+    assert queue._list_cursor == 2
+    assert queue._peers_transactions_queues[peer1].deficit == 5
+    assert queue._peers_transactions_queues[peer2].deficit == 0
+    assert queue._peers_transactions_queues[peer3].deficit == 5
+    assert queue._peers_transactions_queues[peer4].deficit == 5
+    # Now peer3, peer4 and peer1 can't afford to send their top transactions so
+    # we add the lowest cost among transactions (10) to their deficit counters
+    # and try again. This makes peer3 able to send its transaction tx3.
+    entry = await queue.pop()
+    assert entry.index == 2  # type: ignore[attr-defined]
+    assert queue._list_cursor == 3
+    assert queue._peers_transactions_queues[peer1].deficit == 15
+    assert queue._peers_transactions_queues[peer2].deficit == 0
+    assert queue._peers_transactions_queues[peer3].deficit == 0
+    assert queue._peers_transactions_queues[peer4].deficit == 15
+    # Let's force cleanup to happen on the next pop
+    queue._cleanup_counter = 99
+    # Now peer4 can't afford to send its top transaction (20) but peer1 can
+    # send tx1 (15) so it does.
+    entry = await queue.pop()
+    assert entry.index == 0  # type: ignore[attr-defined]
+    # This pop triggers cleanup, so peer1, peer2 and peer3 are removed from
+    # the transaction queue (they have nothing left) and only peer4 remains.
+    for peer in [peer1, peer2, peer3]:
+        assert peer not in queue._index_to_peer_map
+        assert peer not in queue._peers_transactions_queues
+    assert len(queue._index_to_peer_map) == 1
+    assert peer4 in queue._index_to_peer_map
+    assert queue._list_cursor == 0
+    # At this point we didn't have to increment deficit counters because peer1
+    # could already afford to send its top transaction, so peer4's deficit
+    # counter stays the same.
+    assert queue._peers_transactions_queues[peer4].deficit == 15
+    # Finally, peer4 is tried but it can't send its top transaction, which has
+    # a fallback cost of `test_max_tx_clvm_cost` (20), so we add that to its
+    # deficit counter, making it 35, and upon retrying now it's able to send
+    # its transaction tx4.
+    entry = await queue.pop()
+    assert entry.index == 3  # type: ignore[attr-defined]
+    assert queue._peers_transactions_queues[peer4].deficit == 0
+    assert queue._list_cursor == 0