Tidy messages, publish all Batches to the coordinator

Prior, we published SignedBatches, yet Batches are necessary for auditing
purposes.

processor/scanner/src/db.rs

@@ -525,12 +525,19 @@ db_channel! {
 
 pub(crate) struct SubstrateToEventualityDb;
 impl SubstrateToEventualityDb {
-  pub(crate) fn send_burns(
+  pub(crate) fn send_burns<S: ScannerFeed>(
     txn: &mut impl DbTxn,
     acknowledged_block: u64,
-    burns: &Vec<OutInstructionWithBalance>,
+    burns: Vec<OutInstructionWithBalance>,
   ) {
-    Burns::send(txn, acknowledged_block, burns);
+    // Drop burns less than the dust
+    let burns = burns
+      .into_iter()
+      .filter(|burn| burn.balance.amount.0 >= S::dust(burn.balance.coin).0)
+      .collect::<Vec<_>>();
+    if !burns.is_empty() {
+      Burns::send(txn, acknowledged_block, &burns);
+    }
   }
 
   pub(crate) fn try_recv_burns(
@@ -548,6 +555,7 @@ mod _public_db {
 
   db_channel! {
     ScannerPublic {
+      Batches: (empty_key: ()) -> Batch,
       BatchesToSign: (key: &[u8]) -> Batch,
       AcknowledgedBatches: (key: &[u8]) -> u32,
       CompletedEventualities: (key: &[u8]) -> [u8; 32],
@@ -555,7 +563,24 @@ mod _public_db {
   }
 }
 
+/// The batches to publish.
+///
+/// This is used for auditing the Batches published to Serai.
+pub struct Batches;
+impl Batches {
+  pub(crate) fn send(txn: &mut impl DbTxn, batch: &Batch) {
+    _public_db::Batches::send(txn, (), batch);
+  }
+
+  /// Receive a batch to publish.
+  pub fn try_recv(txn: &mut impl DbTxn) -> Option<Batch> {
+    _public_db::Batches::try_recv(txn, ())
+  }
+}
+
 /// The batches to sign and publish.
+///
+/// This is used for publishing Batches onto Serai.
 pub struct BatchesToSign<K: GroupEncoding>(PhantomData<K>);
 impl<K: GroupEncoding> BatchesToSign<K> {
   pub(crate) fn send(txn: &mut impl DbTxn, key: &K, batch: &Batch) {

processor/scanner/src/report/mod.rs

@@ -8,7 +8,7 @@ use serai_in_instructions_primitives::{MAX_BATCH_SIZE, Batch};
 
 use primitives::task::ContinuallyRan;
 use crate::{
-  db::{Returnable, ScannerGlobalDb, InInstructionData, ScanToReportDb, BatchesToSign},
+  db::{Returnable, ScannerGlobalDb, InInstructionData, ScanToReportDb, Batches, BatchesToSign},
   index,
   scan::next_to_scan_for_outputs_block,
   ScannerFeed, KeyFor,
@@ -160,6 +160,7 @@ impl<D: Db, S: ScannerFeed> ContinuallyRan for ReportTask<D, S> {
         }
 
         for batch in batches {
+          Batches::send(&mut txn, &batch);
           BatchesToSign::send(&mut txn, &external_key_for_session_to_sign_batch, &batch);
         }
       }

processor/scanner/src/substrate/mod.rs

@@ -144,16 +144,9 @@ impl<D: Db, S: ScannerFeed> ContinuallyRan for SubstrateTask<D, S> {
             }
           }
 
-          // Drop burns less than the dust
-          let burns = burns
-            .into_iter()
-            .filter(|burn| burn.balance.amount.0 >= S::dust(burn.balance.coin).0)
-            .collect::<Vec<_>>();
-          if !burns.is_empty() {
-            // We send these Burns as stemming from this block we just acknowledged
-            // This causes them to be acted on after we accumulate the outputs from this block
-            SubstrateToEventualityDb::send_burns(&mut txn, block_number, &burns);
-          }
+          // We send these Burns as stemming from this block we just acknowledged
+          // This causes them to be acted on after we accumulate the outputs from this block
+          SubstrateToEventualityDb::send_burns::<S>(&mut txn, block_number, burns);
         }
 
         Action::QueueBurns(burns) => {
@@ -163,7 +156,7 @@ impl<D: Db, S: ScannerFeed> ContinuallyRan for SubstrateTask<D, S> {
           let queue_as_of = ScannerGlobalDb::<S>::highest_acknowledged_block(&txn)
             .expect("queueing Burns yet never acknowledged a block");
 
-          SubstrateToEventualityDb::send_burns(&mut txn, queue_as_of, &burns);
+          SubstrateToEventualityDb::send_burns::<S>(&mut txn, queue_as_of, burns);
         }
       }