Have the Eventuality task drop outputs which aren't ours and aren't worth it to aggregate

We could drop these entirely, yet there's some degree of utility to be able to
add coins to Serai in this manner.

processor/scanner/src/eventuality/mod.rs

@@ -1,4 +1,4 @@
-use std::collections::HashMap;
+use std::collections::{HashSet, HashMap};
 
 use group::GroupEncoding;
 
@@ -288,7 +288,6 @@ impl<D: Db, S: ScannerFeed, Sch: Scheduler<S>> ContinuallyRan for EventualityTas
         let mut non_external_outputs = block.scan_for_outputs(key.key);
         non_external_outputs.retain(|output| output.kind() != OutputType::External);
         // Drop any outputs less than the dust limit
-        // TODO: Either further filter to outputs we made or also check cost_to_aggregate
         non_external_outputs.retain(|output| {
           let balance = output.balance();
           balance.amount.0 >= self.feed.dust(balance.coin).0
@@ -315,6 +314,31 @@ impl<D: Db, S: ScannerFeed, Sch: Scheduler<S>> ContinuallyRan for EventualityTas
             .retain(|output| completed_eventualities.contains_key(&output.transaction_id()));
         }
 
+        // Finally, for non-External outputs we didn't make, we check they're worth more than the
+        // cost to aggregate them to avoid some profitable spam attacks by malicious miners
+        {
+          // Fetch and cache the costs to aggregate as this call may be expensive
+          let coins =
+            non_external_outputs.iter().map(|output| output.balance().coin).collect::<HashSet<_>>();
+          let mut costs_to_aggregate = HashMap::new();
+          for coin in coins {
+            costs_to_aggregate.insert(
+              coin,
+              self.feed.cost_to_aggregate(coin, &block).await.map_err(|e| {
+                format!("EventualityTask couldn't fetch cost to aggregate {coin:?} at {b}: {e:?}")
+              })?,
+            );
+          }
+
+          // Only retain out outputs/outputs sufficiently worthwhile
+          non_external_outputs.retain(|output| {
+            completed_eventualities.contains_key(&output.transaction_id()) || {
+              let balance = output.balance();
+              balance.amount.0 >= (2 * costs_to_aggregate[&balance.coin].0)
+            }
+          });
+        }
+
         // Now, we iterate over all Forwarded outputs and queue their InInstructions
         for output in
           non_external_outputs.iter().filter(|output| output.kind() == OutputType::Forwarded)

processor/scanner/src/scan/mod.rs

@@ -226,7 +226,10 @@ impl<D: Db, S: ScannerFeed> ContinuallyRan for ScanTask<D, S> {
               costs_to_aggregate.entry(balance.coin)
             {
               e.insert(self.feed.cost_to_aggregate(balance.coin, &block).await.map_err(|e| {
-                format!("couldn't fetch cost to aggregate {:?} at {b}: {e:?}", balance.coin)
+                format!(
+                  "ScanTask couldn't fetch cost to aggregate {:?} at {b}: {e:?}",
+                  balance.coin
+                )
               })?);
             }
             let cost_to_aggregate = costs_to_aggregate[&balance.coin];