Convert coordinator/substrate/db to use create_db macro (#436)

* chore: implement create_db for substrate (fix broken branch)

* Correct rebase artifacts

* chore: remove todo statement

* chore: rename BlockDb to NextBlock

* chore: return empty tuple instead of empty array for event storage

* Finish rebasing

* .Minor tweaks to remove leftover variables

These may be rebase artifacts.

---------

Co-authored-by: Luke Parker <lukeparker5132@gmail.com>

coordinator/src/substrate/db.rs

@@ -7,13 +7,17 @@ use serai_client::{
 
 pub use serai_db::*;
 
-create_db! {
+create_db!(
   SubstrateDb {
     CosignTriggered: () -> (),
     IntendedCosign: () -> (u64, Option<u64>),
     BlockHasEvents: (block: u64) -> u8,
+    LatestCosignedBlock: () -> u64,
+    NextBlock: () -> u64,
+    EventDb: (id: &[u8], index: u32) -> (),
+    BatchInstructionsHashDb: (network: NetworkId, id: u32) -> [u8; 32]
   }
-}
+);
 
 impl IntendedCosign {
   pub fn set_intended_cosign(txn: &mut impl DbTxn, intended: u64) {
@@ -26,82 +30,32 @@ impl IntendedCosign {
   }
 }
 
+impl LatestCosignedBlock {
+  pub fn latest_cosigned_block(getter: &impl Get) -> u64 {
+    Self::get(getter).unwrap_or_default().max(1)
+  }
+}
+
+impl EventDb {
+  pub fn is_unhandled(getter: &impl Get, id: &[u8], index: u32) -> bool {
+    Self::get(getter, id, index).is_none()
+  }
+
+  pub fn handle_event(txn: &mut impl DbTxn, id: &[u8], index: u32) {
+    assert!(Self::is_unhandled(txn, id, index));
+    Self::set(txn, id, index, &());
+  }
+}
+
 db_channel! {
-  SubstrateDb {
+  SubstrateDbChannels {
     CosignTransactions: (network: NetworkId) -> (Session, u64, [u8; 32]),
   }
 }
+
 impl CosignTransactions {
   // Append a cosign transaction.
   pub fn append_cosign(txn: &mut impl DbTxn, set: ValidatorSet, number: u64, hash: [u8; 32]) {
     CosignTransactions::send(txn, set.network, &(set.session, number, hash))
   }
 }
-
-#[derive(Debug)]
-pub struct SubstrateDb<D: Db>(pub D);
-impl<D: Db> SubstrateDb<D> {
-  pub fn new(db: D) -> Self {
-    Self(db)
-  }
-
-  fn substrate_key(dst: &'static [u8], key: impl AsRef<[u8]>) -> Vec<u8> {
-    D::key(b"coordinator_substrate", dst, key)
-  }
-
-  fn next_block_key() -> Vec<u8> {
-    Self::substrate_key(b"next_block", [])
-  }
-  pub fn set_next_block(&mut self, block: u64) {
-    let mut txn = self.0.txn();
-    txn.put(Self::next_block_key(), block.to_le_bytes());
-    txn.commit();
-  }
-  pub fn next_block(&self) -> u64 {
-    u64::from_le_bytes(self.0.get(Self::next_block_key()).unwrap_or(vec![0; 8]).try_into().unwrap())
-  }
-
-  fn latest_cosigned_block_key() -> Vec<u8> {
-    Self::substrate_key(b"latest_cosigned_block", [])
-  }
-  pub fn set_latest_cosigned_block(txn: &mut D::Transaction<'_>, latest_cosigned_block: u64) {
-    txn.put(Self::latest_cosigned_block_key(), latest_cosigned_block.to_le_bytes());
-  }
-  pub fn latest_cosigned_block<G: Get>(getter: &G) -> u64 {
-    let db = u64::from_le_bytes(
-      getter.get(Self::latest_cosigned_block_key()).unwrap_or(vec![0; 8]).try_into().unwrap(),
-    );
-    // Mark the genesis as cosigned
-    db.max(1)
-  }
-
-  fn event_key(id: &[u8], index: u32) -> Vec<u8> {
-    Self::substrate_key(b"event", [id, index.to_le_bytes().as_ref()].concat())
-  }
-  pub fn handled_event<G: Get>(getter: &G, id: [u8; 32], index: u32) -> bool {
-    getter.get(Self::event_key(&id, index)).is_some()
-  }
-  pub fn handle_event(txn: &mut D::Transaction<'_>, id: [u8; 32], index: u32) {
-    assert!(!Self::handled_event(txn, id, index));
-    txn.put(Self::event_key(&id, index), []);
-  }
-
-  fn batch_instructions_key(network: NetworkId, id: u32) -> Vec<u8> {
-    Self::substrate_key(b"batch", (network, id).encode())
-  }
-  pub fn batch_instructions_hash<G: Get>(
-    getter: &G,
-    network: NetworkId,
-    id: u32,
-  ) -> Option<[u8; 32]> {
-    getter.get(Self::batch_instructions_key(network, id)).map(|bytes| bytes.try_into().unwrap())
-  }
-  pub fn save_batch_instructions_hash(
-    txn: &mut D::Transaction<'_>,
-    network: NetworkId,
-    id: u32,
-    hash: [u8; 32],
-  ) {
-    txn.put(Self::batch_instructions_key(network, id), hash);
-  }
-}