Make sure the fee and cost specified in a NewTransaction match the ones from validating its spend bundle.

Author: AmineKhaldi

chia/_tests/core/full_node/test_full_node.py

@@ -3362,18 +3362,21 @@ async def test_pending_tx_cache_retry_on_new_peak(
 @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])
 async def test_ban_for_mismatched_tx_cost_fee(
     setup_two_nodes_fixture: tuple[list[FullNodeSimulator], list[tuple[WalletNode, ChiaServer]], BlockTools],
     self_hostname: str,
     mismatch_cost: bool,
     mismatch_fee: bool,
+    tx_already_seen: 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 two full nodes with the test transaction as already seen, and we
-    check its validation cost and fee against the ones specified in the
-    `NewTransaction` message.
+    We setup two 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.
     """
     nodes, _, bt = setup_two_nodes_fixture
     full_node_1, full_node_2 = nodes
@@ -3384,17 +3387,26 @@ async def test_ban_for_mismatched_tx_cost_fee(
     ws_con_2 = next(iter(server_2.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, pool_reward_puzzle_hash=wallet_ph
     )
     for block in blocks:
-        await full_node_1.full_node.add_block(block)
+        await node.add_block(block)
     # Create a transaction and add it to the relevant full node's mempool
     coin = blocks[-1].get_included_reward_coins()[0]
     sb = wallet.generate_signed_transaction(uint64(42), wallet_ph, coin)
     sb_name = sb.name()
-    await full_node_1.full_node.add_transaction(sb, sb_name, ws_con_1)
-    mempool_item = full_node_1.full_node.mempool_manager.get_mempool_item(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.
@@ -3407,6 +3419,14 @@ async def test_ban_for_mismatched_tx_cost_fee(
     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
     await ws_con_2.send_message(msg)
+    if not tx_already_seen:
+        # When the first full node receives the NewTransaction message and it
+        # hasen'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(
+            10, lambda: full_node_1.full_node.mempool_manager.get_mempool_item(mempool_item.name) is not None
+        )
     # 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.

chia/full_node/full_node_api.py

@@ -226,8 +226,16 @@ async def tx_request_and_timeout(full_node: FullNode, transaction_id: bytes32, t
                         await random_peer.send_message(msg)
                         await asyncio.sleep(5)
                         counter += 1
-                        if full_node.mempool_manager.seen(transaction_id):
-                            break
+                        mempool_item = full_node.mempool_manager.get_mempool_item(transaction_id)
+                        if mempool_item is not None:
+                            if mempool_item.cost == transaction.cost and mempool_item.fee == transaction.fees:
+                                break
+                            self.log.warning(
+                                f"Banning peer {peer.peer_node_id}. Sent us a new tx {transaction_id} with mismatch "
+                                f"on cost {transaction.cost} vs validation cost {mempool_item.cost} and/or "
+                                f"fee {transaction.fees} vs {mempool_item.fee}."
+                            )
+                            await peer.close(RATE_LIMITER_BAN_SECONDS)
                 except asyncio.CancelledError:
                     pass
                 finally: