we are async

src/disk_drive.rs

···
 }
 
 pub trait BlockStore<MPB: Serialize + DeserializeOwned> {
-    fn put_batch(&self, blocks: Vec<(Cid, MPB)>); // unwraps for now
+    fn put_batch(&self, blocks: Vec<(Cid, MPB)>) -> impl std::future::Future<Output = ()> + Send; // unwraps for now
     fn get(&self, key: Cid) -> Option<MPB>;
 }
 
···
                     to_insert.push((cid, data));
                 }
             }
-            block_store.put_batch(to_insert)
+            block_store.put_batch(to_insert).await;
         }
 
         log::warn!("init: got commit?");

src/disk_redb.rs

···
 use crate::disk_drive::BlockStore;
 use ipld_core::cid::Cid;
 use redb::{Database, Durability, Error, ReadableDatabase, TableDefinition};
-use serde::{Serialize, de::DeserializeOwned};
 use std::path::Path;
+use std::sync::Arc;
 
 const TABLE: TableDefinition<&[u8], &[u8]> = TableDefinition::new("blocks");
 
 pub struct RedbStore {
     #[allow(dead_code)]
-    db: Database,
+    db: Arc<Database>,
 }
 
 impl RedbStore {
···
         log::warn!("redb new");
         let db = Database::create(path)?;
         log::warn!("db created");
-        Ok(Self { db })
+        Ok(Self { db: db.into() })
     }
 }
 
···
     }
 }
 
-impl<MPB: Serialize + DeserializeOwned> BlockStore<MPB> for RedbStore {
-    fn put_batch(&self, blocks: Vec<(Cid, MPB)>) {
-        let mut tx = self.db.begin_write().unwrap();
-        tx.set_durability(Durability::None).unwrap();
+impl BlockStore<Vec<u8>> for RedbStore {
+    async fn put_batch(&self, blocks: Vec<(Cid, Vec<u8>)>) {
+        let db = self.db.clone();
+        tokio::task::spawn_blocking(move || {
+            let mut tx = db.begin_write().unwrap();
+            tx.set_durability(Durability::None).unwrap();
 
-        {
-            let mut table = tx.open_table(TABLE).unwrap();
-            for (cid, t) in blocks {
-                let key_bytes = cid.to_bytes();
-                let val_bytes =
-                    bincode::serde::encode_to_vec(t, bincode::config::standard()).unwrap();
-                table.insert(&*key_bytes, &*val_bytes).unwrap();
+            {
+                let mut table = tx.open_table(TABLE).unwrap();
+                for (cid, t) in blocks {
+                    let key_bytes = cid.to_bytes();
+                    table.insert(&*key_bytes, &*t).unwrap();
+                }
             }
-        }
 
-        tx.commit().unwrap();
+            tx.commit().unwrap();
+        }).await.unwrap();
     }
 
-    fn get(&self, c: Cid) -> Option<MPB> {
+    fn get(&self, c: Cid) -> Option<Vec<u8>> {
         let key_bytes = c.to_bytes();
         let tx = self.db.begin_read().unwrap();
         let table = tx.open_table(TABLE).unwrap();
-        let maybe_val_bytes = table.get(&*key_bytes).unwrap()?;
-        let (t, n): (MPB, usize) =
-            bincode::serde::decode_from_slice(maybe_val_bytes.value(), bincode::config::standard())
-                .unwrap();
-        assert_eq!(maybe_val_bytes.value().len(), n);
+        let t = table.get(&*key_bytes).unwrap()?.value().to_vec();
         Some(t)
     }
 }