chia-blockchain 2.5.8rc1__py3-none-any.whl → 2.6.0rc3__py3-none-any.whl

chia/_tests/blockchain/test_blockchain_transactions.py

@@ -8,6 +8,7 @@ from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64
 
 from chia._tests.blockchain.blockchain_test_utils import _validate_and_add_block
+from chia._tests.connection_utils import add_dummy_connection
 from chia._tests.util.generator_tools_testing import run_and_get_removals_and_additions
 from chia.consensus.blockchain import AddBlockResult
 from chia.full_node.full_node_api import FullNodeAPI
@@ -34,7 +35,7 @@ log = logging.getLogger(__name__)
 class TestBlockchainTransactions:
     @pytest.mark.anyio
     async def test_basic_blockchain_tx(
-        self, two_nodes: tuple[FullNodeAPI, FullNodeAPI, ChiaServer, ChiaServer, BlockTools]
+        self, two_nodes: tuple[FullNodeAPI, FullNodeAPI, ChiaServer, ChiaServer, BlockTools], self_hostname: str
     ) -> None:
         num_blocks = 10
         wallet_a = WALLET_A
@@ -60,7 +61,9 @@ class TestBlockchainTransactions:
         assert spend_bundle is not None
         tx: wallet_protocol.SendTransaction = wallet_protocol.SendTransaction(spend_bundle)
 
-        await full_node_api_1.send_transaction(tx)
+        _, dummy_node_id = await add_dummy_connection(full_node_api_1.server, self_hostname, 12312)
+        dummy_peer = full_node_api_1.server.all_connections[dummy_node_id]
+        await full_node_api_1.send_transaction(tx, dummy_peer)
 
         sb = full_node_1.mempool_manager.get_spendbundle(spend_bundle.name())
         assert sb == spend_bundle

chia/_tests/conftest.py

@@ -208,13 +208,14 @@ def get_keychain():
 class ConsensusMode(ComparableEnum):
     PLAIN = 0
     HARD_FORK_2_0 = 1
-    HARD_FORK_3_0 = 2
+    SOFT_FORK_2_6 = 2
+    HARD_FORK_3_0 = 3
 
 
 @pytest.fixture(
     scope="session",
     # TODO: todo_v2_plots add HARD_FORK_3_0 mode as well as after phase-out
-    params=[ConsensusMode.PLAIN, ConsensusMode.HARD_FORK_2_0],
+    params=[ConsensusMode.PLAIN, ConsensusMode.HARD_FORK_2_0, ConsensusMode.SOFT_FORK_2_6],
 )
 def consensus_mode(request):
     return request.param
@@ -231,6 +232,11 @@ def blockchain_constants(consensus_mode: ConsensusMode) -> ConsensusConstants:
             PLOT_FILTER_32_HEIGHT=uint32(20),
         )
 
+    if consensus_mode >= ConsensusMode.SOFT_FORK_2_6:
+        ret = ret.replace(
+            SOFT_FORK8_HEIGHT=uint32(2),
+        )
+
     if consensus_mode >= ConsensusMode.HARD_FORK_3_0:
         ret = ret.replace(
             HARD_FORK_HEIGHT=uint32(2),

chia/_tests/core/full_node/test_full_node.py

@@ -36,7 +36,7 @@ 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
@@ -1032,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)
@@ -1083,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
 
@@ -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(
@@ -3254,6 +3266,7 @@ 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,
@@ -3269,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
@@ -3312,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
@@ -3344,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)
@@ -3520,3 +3539,24 @@ async def test_corrupt_blockchain(bt: BlockTools, default_400_blocks: list[FullB
         # 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"

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_prev_tx_block.py

@@ -15,14 +15,14 @@ def test_prev_tx_block_none() -> None:
         blocks=BlockCache({}),
         prev_b_hash=test_constants.GENESIS_CHALLENGE,
         sp_index=uint8(0),
-        first_in_sub_slot=False,
+        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),
-        first_in_sub_slot=True,
+        finished_sub_slots=1,
     ) == uint32(0)
 
 
@@ -43,7 +43,7 @@ def test_prev_tx_block_blockrecord_tx(bt: BlockTools) -> None:
             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,
+            finished_sub_slots=len(block.finished_sub_slots),
         )
         == latest_tx_before_sp.height
     )
@@ -56,7 +56,7 @@ def test_prev_tx_block_blockrecord_tx(bt: BlockTools) -> None:
             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,
+            finished_sub_slots=len(block.finished_sub_slots),
         )
         == latest_tx_before_sp.height
     )
@@ -69,7 +69,7 @@ def test_prev_tx_block_blockrecord_tx(bt: BlockTools) -> None:
             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,
+            finished_sub_slots=len(block.finished_sub_slots),
         )
         == latest_tx_before_sp.height
     )
@@ -95,7 +95,7 @@ def test_prev_tx_block_blockrecord_not_tx(bt: BlockTools) -> None:
         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,
+        finished_sub_slots=len(block.finished_sub_slots),
     ) == uint32(latest_tx_before_sp.height)
 
 

chia/_tests/core/full_node/test_tx_processing_queue.py

@@ -13,10 +13,13 @@ from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint64
 
 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:
@@ -35,7 +38,7 @@ def get_transaction_queue_entry(
 
 @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)
     transaction_queue.put(first_tx, None)
@@ -60,7 +63,7 @@ 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)
 
@@ -94,7 +97,7 @@ async def test_one_peer_and_await(seeded_random: random.Random) -> None:
 
 @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
@@ -116,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
@@ -138,7 +141,7 @@ 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)
@@ -201,7 +204,7 @@ async def test_peer_queue_prioritization_fallback() -> None:
     """
     Tests prioritization fallback, when `peer_id` is not in `peers_with_tx`.
     """
-    queue = TransactionQueue(42, log)
+    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
@@ -226,13 +229,94 @@ async def test_peer_queue_prioritization_fallback() -> None:
     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._queue_dict[peer3].queue[0][0], -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._queue_dict[peer3].queue[0][0])
+    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

chia/_tests/core/mempool/test_mempool.py

@@ -395,15 +395,17 @@ co = ConditionOpcode
 mis = MempoolInclusionStatus
 
 
-async def send_sb(node: FullNodeAPI, sb: SpendBundle) -> Message | None:
+async def send_sb(node: FullNodeAPI, dummy_peer: WSChiaConnection, sb: SpendBundle) -> Message | None:
     tx = wallet_protocol.SendTransaction(sb)
-    return await node.send_transaction(tx, test=True)
+    return await node.send_transaction(tx, dummy_peer, test=True)
 
 
-async def gen_and_send_sb(node: FullNodeAPI, wallet: WalletTool, coin: Coin, fee: uint64 = uint64(0)) -> SpendBundle:
+async def gen_and_send_sb(
+    node: FullNodeAPI, dummy_peer: WSChiaConnection, wallet: WalletTool, coin: Coin, fee: uint64 = uint64(0)
+) -> SpendBundle:
     sb = generate_test_spend_bundle(wallet=wallet, coin=coin, fee=fee)
     assert sb is not None
-    await send_sb(node, sb)
+    await send_sb(node, dummy_peer, sb)
     return sb
 
 
@@ -611,7 +613,10 @@ class TestMempoolManager:
 
     @pytest.mark.anyio
     async def test_double_spend_with_higher_fee(
-        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self,
+        one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools],
+        wallet_a: WalletTool,
+        self_hostname: str,
     ) -> None:
         full_node_1, _, bt = one_node_one_block
         blocks = await full_node_1.get_all_full_blocks()
@@ -633,15 +638,17 @@ class TestMempoolManager:
         coins = iter(blocks[-2].get_included_reward_coins())
         coin3, coin4 = next(coins), next(coins)
 
-        sb1_1 = await gen_and_send_sb(full_node_1, wallet_a, coin1)
-        sb1_2 = await gen_and_send_sb(full_node_1, wallet_a, coin1, fee=uint64(1))
+        _, dummy_node_id = await add_dummy_connection(full_node_1.server, self_hostname, 12312)
+        dummy_peer = full_node_1.server.all_connections[dummy_node_id]
+        sb1_1 = await gen_and_send_sb(full_node_1, dummy_peer, wallet_a, coin1)
+        sb1_2 = await gen_and_send_sb(full_node_1, dummy_peer, wallet_a, coin1, fee=uint64(1))
 
         # Fee increase is insufficient, the old spendbundle must stay
         assert_sb_in_pool(full_node_1.full_node.mempool_manager, sb1_1)
         assert_sb_not_in_pool(full_node_1.full_node.mempool_manager, sb1_2)
         invariant_check_mempool(full_node_1.full_node.mempool_manager.mempool)
 
-        sb1_3 = await gen_and_send_sb(full_node_1, wallet_a, coin1, fee=MEMPOOL_MIN_FEE_INCREASE)
+        sb1_3 = await gen_and_send_sb(full_node_1, dummy_peer, wallet_a, coin1, fee=MEMPOOL_MIN_FEE_INCREASE)
 
         # Fee increase is sufficiently high, sb1_1 gets replaced with sb1_3
         assert_sb_not_in_pool(full_node_1.full_node.mempool_manager, sb1_1)
@@ -650,7 +657,7 @@ class TestMempoolManager:
 
         sb2 = generate_test_spend_bundle(wallet_a, coin2, fee=MEMPOOL_MIN_FEE_INCREASE)
         sb12 = SpendBundle.aggregate([sb2, sb1_3])
-        await send_sb(full_node_1, sb12)
+        await send_sb(full_node_1, dummy_peer, sb12)
 
         # Aggregated spendbundle sb12 replaces sb1_3 since it spends a superset
         # of coins spent in sb1_3
@@ -660,7 +667,7 @@ class TestMempoolManager:
 
         sb3 = generate_test_spend_bundle(wallet_a, coin3, fee=uint64(MEMPOOL_MIN_FEE_INCREASE * 2))
         sb23 = SpendBundle.aggregate([sb2, sb3])
-        await send_sb(full_node_1, sb23)
+        await send_sb(full_node_1, dummy_peer, sb23)
 
         # sb23 must not replace existing sb12 as the former does not spend all
         # coins that are spent in the latter (specifically, coin1)
@@ -668,21 +675,21 @@ class TestMempoolManager:
         assert_sb_not_in_pool(full_node_1.full_node.mempool_manager, sb23)
         invariant_check_mempool(full_node_1.full_node.mempool_manager.mempool)
 
-        await send_sb(full_node_1, sb3)
+        await send_sb(full_node_1, dummy_peer, sb3)
         # Adding non-conflicting sb3 should succeed
         assert_sb_in_pool(full_node_1.full_node.mempool_manager, sb3)
         invariant_check_mempool(full_node_1.full_node.mempool_manager.mempool)
 
         sb4_1 = generate_test_spend_bundle(wallet_a, coin4, fee=MEMPOOL_MIN_FEE_INCREASE)
         sb1234_1 = SpendBundle.aggregate([sb12, sb3, sb4_1])
-        await send_sb(full_node_1, sb1234_1)
+        await send_sb(full_node_1, dummy_peer, sb1234_1)
         # sb1234_1 should not be in pool as it decreases total fees per cost
         assert_sb_not_in_pool(full_node_1.full_node.mempool_manager, sb1234_1)
         invariant_check_mempool(full_node_1.full_node.mempool_manager.mempool)
 
         sb4_2 = generate_test_spend_bundle(wallet_a, coin4, fee=uint64(MEMPOOL_MIN_FEE_INCREASE * 2))
         sb1234_2 = SpendBundle.aggregate([sb12, sb3, sb4_2])
-        await send_sb(full_node_1, sb1234_2)
+        await send_sb(full_node_1, dummy_peer, sb1234_2)
         # sb1234_2 has a higher fee per cost than its conflicts and should get
         # into mempool
         assert_sb_in_pool(full_node_1.full_node.mempool_manager, sb1234_2)
@@ -692,7 +699,10 @@ class TestMempoolManager:
 
     @pytest.mark.anyio
     async def test_invalid_signature(
-        self, one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools], wallet_a: WalletTool
+        self,
+        one_node_one_block: tuple[FullNodeSimulator, ChiaServer, BlockTools],
+        wallet_a: WalletTool,
+        self_hostname: str,
     ) -> None:
         reward_ph = wallet_a.get_new_puzzlehash()
 
@@ -714,7 +724,9 @@ class TestMempoolManager:
         sb: SpendBundle = generate_test_spend_bundle(wallet_a, coin1)
         assert sb.aggregated_signature != G2Element.generator()
         sb = sb.replace(aggregated_signature=G2Element.generator())
-        res: Message | None = await send_sb(full_node_1, sb)
+        _, dummy_node_id = await add_dummy_connection(full_node_1.server, self_hostname, 12312)
+        dummy_peer = full_node_1.server.all_connections[dummy_node_id]
+        res: Message | None = await send_sb(full_node_1, dummy_peer, sb)
         assert res is not None
         ack: TransactionAck = TransactionAck.from_bytes(res.data)
         assert ack.status == MempoolInclusionStatus.FAILED.value