Have acknowledge_block take in the results of the InInstructions executed

If any failed, the scanner now creates a Burn for the return.

processor/scanner/src/report/db.rs

@@ -1,16 +1,34 @@
+use core::marker::PhantomData;
+use std::io::{Read, Write};
+
+use scale::{Encode, Decode, IoReader};
 use serai_db::{Get, DbTxn, create_db};
 
+use serai_primitives::Balance;
+
+use primitives::Address;
+
+use crate::{ScannerFeed, AddressFor};
+
 create_db!(
   ScannerReport {
     // The next block to potentially report
     NextToPotentiallyReportBlock: () -> u64,
     // The next Batch ID to use
     NextBatchId: () -> u32,
+
+    // The return addresses for the InInstructions within a Batch
+    SerializedReturnAddresses: (batch: u32) -> Vec<u8>,
   }
 );
 
-pub(crate) struct ReportDb;
-impl ReportDb {
+pub(crate) struct ReturnInformation<S: ScannerFeed> {
+  pub(crate) address: AddressFor<S>,
+  pub(crate) balance: Balance,
+}
+
+pub(crate) struct ReportDb<S: ScannerFeed>(PhantomData<S>);
+impl<S: ScannerFeed> ReportDb<S> {
   pub(crate) fn set_next_to_potentially_report_block(
     txn: &mut impl DbTxn,
     next_to_potentially_report_block: u64,
@@ -26,4 +44,43 @@ impl ReportDb {
     NextBatchId::set(txn, &(id + 1));
     id
   }
+
+  pub(crate) fn save_return_information(
+    txn: &mut impl DbTxn,
+    id: u32,
+    return_information: &Vec<Option<ReturnInformation<S>>>,
+  ) {
+    let mut buf = Vec::with_capacity(return_information.len() * (32 + 1 + 8));
+    for return_information in return_information {
+      if let Some(ReturnInformation { address, balance }) = return_information {
+        buf.write_all(&[1]).unwrap();
+        address.write(&mut buf).unwrap();
+        balance.encode_to(&mut buf);
+      } else {
+        buf.write_all(&[0]).unwrap();
+      }
+    }
+    SerializedReturnAddresses::set(txn, id, &buf);
+  }
+  pub(crate) fn take_return_information(
+    txn: &mut impl DbTxn,
+    id: u32,
+  ) -> Option<Vec<Option<ReturnInformation<S>>>> {
+    let buf = SerializedReturnAddresses::get(txn, id)?;
+    let mut buf = buf.as_slice();
+
+    let mut res = Vec::with_capacity(buf.len() / (32 + 1 + 8));
+    while !buf.is_empty() {
+      let mut opt = [0xff];
+      buf.read_exact(&mut opt).unwrap();
+      assert!((opt[0] == 0) || (opt[0] == 1));
+
+      res.push((opt[0] == 1).then(|| {
+        let address = AddressFor::<S>::read(&mut buf).unwrap();
+        let balance = Balance::decode(&mut IoReader(&mut buf)).unwrap();
+        ReturnInformation { address, balance }
+      }));
+    }
+    Some(res)
+  }
 }