*: serialize on disk with bincode2 instead of serde

Cargo.lock

···
 dependencies = [
  "anyhow",
  "async-compression",
+ "bincode",
  "bytevec",
  "chrono",
  "clap",
···
 version = "0.22.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+
+[[package]]
+name = "bincode"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36eaf5d7b090263e8150820482d5d93cd964a81e4019913c972f4edcc6edb740"
+dependencies = [
+ "bincode_derive",
+ "serde",
+ "unty",
+]
+
+[[package]]
+name = "bincode_derive"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf95709a440f45e986983918d0e8a1f30a9b1df04918fc828670606804ac3c09"
+dependencies = [
+ "virtue",
+]
 
 [[package]]
 name = "bindgen"
···
 checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
 
 [[package]]
+name = "unty"
+version = "0.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d49784317cd0d1ee7ec5c716dd598ec5b4483ea832a2dced265471cc0f690ae"
+
+[[package]]
 name = "url"
 version = "2.5.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "virtue"
+version = "0.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "051eb1abcf10076295e815102942cc58f9d5e3b4560e46e53c21e8ff6f3af7b1"
 
 [[package]]
 name = "want"

Cargo.toml

···
 [dependencies]
 anyhow = "1.0.99"
 async-compression = { version = "0.4.30", features = ["futures-io", "tokio", "gzip"] }
+bincode = { version = "2.0.1", features = ["derive"] }
 bytevec = "0.2.0"
 chrono = { version = "0.4.42", features = ["serde"] }
 clap = { version = "4.5.47", features = ["derive", "env"] }

src/plc_rocksdb.rs

···
 use async_compression::tokio::write::{GzipDecoder, GzipEncoder};
-use futures::{TryFutureExt, stream};
+use futures::stream;
 use rocksdb::Options;
 use serde::{Deserialize, Serialize};
 use std::{path::PathBuf, sync::Arc, time::Instant};
···
         db.put_cf(
             &cf,
             op_key(&op, id),
-            serde_json::to_vec(&RocksOp::from_op(&op).await).unwrap(),
+            bincode::encode_to_vec(&RocksOp::from_op(&op).await, bincode::config::standard())
+                .unwrap(),
         )?;
         self.set_latest_timestamp(&db, op.created_at).await?;
 
···
     }
 }
 
-#[derive(Serialize, Deserialize)]
+#[derive(bincode::Encode, bincode::Decode)]
 struct RocksOp {
     pub did: String,
     pub cid: String,
-    pub created_at: Dt,
+    pub created_at: i64,
     pub nullified: bool,
     pub operation: Vec<u8>,
 }
···
             operation: op_gz,
             did: op.did.clone(),
             cid: op.cid.clone(),
-            created_at: op.created_at,
+            created_at: op.created_at.timestamp_millis(),
             nullified: op.nullified,
         }
     }
···
         Op {
             did: self.did.clone(),
             cid: self.cid.clone(),
-            created_at: self.created_at,
+            created_at: Dt::from_timestamp_millis(self.created_at).unwrap(),
             nullified: self.nullified,
             operation: serde_json::value::RawValue::from_string(dec_op).unwrap(),
         }
···
     }
 
     async fn query_ops(&self, did: String) -> Result<Vec<Op>, Error> {
-        // TODO(geesawra): check if did exists first!
         let db = self.db.lock().await;
 
         let id = match self
···
                     return None;
                 }
 
-                let rop: RocksOp = serde_json::from_slice(&v).unwrap();
+                let asd = bincode::decode_from_slice(&v, bincode::config::standard()).unwrap();
 
-                Some(rop)
+                Some(asd.0)
             })
             .collect();