Don't broadcast orphan messages

Broadcasting orphan messages provides a spam attack vector where it's
simple to create signed txs with invalid inputs and have nodes
rebroadcast spam on your behalf.

This PR prevents orphan transactions being broadcast.

In a subsequent PR, we should broadcast orphns that get promoted to
the unconfirmed pool if intermediate txs in a chain do arrive in the
mempool.

Author: CjS77

base_layer/core/src/mempool/service/inbound_handlers.rs

@@ -135,7 +135,7 @@ where T: BlockchainBackend + 'static
                     );
                     let propagate = match tx_storage {
                         TxStorageResponse::UnconfirmedPool => true,
-                        TxStorageResponse::OrphanPool => true,
+                        TxStorageResponse::OrphanPool => false,
                         TxStorageResponse::PendingPool => true,
                         TxStorageResponse::ReorgPool => false,
                         TxStorageResponse::NotStored => false,

base_layer/core/tests/mempool.rs

@@ -664,31 +664,30 @@ fn receive_and_propagate_transaction() {
             interval = Duration::from_millis(1000)
         );
         async_assert_eventually!(
-            bob_node
+            carol_node
                 .mempool
-                .has_tx_with_excess_sig(orphan_excess_sig.clone())
+                .has_tx_with_excess_sig(tx_excess_sig.clone())
                 .unwrap(),
-            expect = TxStorageResponse::OrphanPool,
-            max_attempts = 10,
-            interval = Duration::from_millis(1000)
+            expect = TxStorageResponse::PendingPool
         );
+        // Carol got sent the orphan tx directly, so it will be in her mempool
         async_assert_eventually!(
             carol_node
                 .mempool
-                .has_tx_with_excess_sig(tx_excess_sig.clone())
+                .has_tx_with_excess_sig(orphan_excess_sig.clone())
                 .unwrap(),
-            expect = TxStorageResponse::PendingPool,
+            expect = TxStorageResponse::OrphanPool,
             max_attempts = 10,
             interval = Duration::from_millis(1000)
         );
+        // It's difficult to test a negative here, but let's at least make sure that the orphan TX was not propagated
+        // by the time we check it
         async_assert_eventually!(
-            carol_node
+            bob_node
                 .mempool
                 .has_tx_with_excess_sig(orphan_excess_sig.clone())
                 .unwrap(),
-            expect = TxStorageResponse::OrphanPool,
-            max_attempts = 10,
-            interval = Duration::from_millis(1000)
+            expect = TxStorageResponse::NotStored,
         );
 
         alice_node.comms.shutdown().await;