feat: private backpointer (#90)

* Encrypt the ratchet key

* Rename `RatchetKey` to `RevisionKey`

* Fix wasm crate

* Rename `*Serde` into `*Serializable`

* Add `previous` backlinks to `PrivateDirectory` schema

* Remember persisted CID in PrivateDirectory

And store previous CID in previous links.

Co-authored-by: Stephen <[email protected]>

* Fixed not resetting `persisted_as` correctly

Co-authored-by: Stephen <[email protected]>

* Also implement `prepare_next_revision` for private files

* Add TODOs for fixing up serialization

* Make use of `let-else` ✨ 💄

* Store `previous` in `PrivateNodeHistory`.

* Resolve bias in previous iterator towards `previous` nodes

* Add docs & test

* Also rotate the `inumber` when re-attaching trees

* fix: Private shard block labels according to spec

https://github.com/wnfs-wg/spec/blob/main/spec/private-wnfs.md#44-sharded-file-content-access

* chore: Remove some logging, reduce diff

* Documentation for `Encrypted`

* Try to align on `impl BlockStore` and `impl RngCore`

* Take a reference (fix incorrect manual merge)

* Force a patch version for chrono

Co-authored-by: Stephen <[email protected]>

wnfs/Cargo.toml

@@ -25,12 +25,13 @@ async-std = { version = "1.11", features = ["attributes"] }
 async-stream = "0.3"
 async-trait = "0.1"
 bitvec = { version = "1.0", features = ["serde"] }
-chrono = { version = "0.4", default-features = false, features = ["clock", "std"] }
+chrono = { version = "0.4.23", default-features = false, features = ["clock", "std"] }
 either = "1.8"
 futures = "0.3"
 futures-util = "0.3"
 libipld = { version = "0.15", features = ["dag-cbor", "derive", "serde-codec"] }
 log = "0.4"
+multihash = "0.16"
 once_cell = "1.16"
 proptest = { version = "1.0", optional = true }
 rand = { version = "0.8", optional = true }

wnfs/examples/private.rs

@@ -41,11 +41,10 @@ async fn main() {
     println!("{:#?}", dir);
 }
 
-async fn get_forest_cid_and_private_ref<B, R>(store: &mut B, rng: &mut R) -> (Cid, PrivateRef)
-where
-    B: BlockStore,
-    R: RngCore,
-{
+async fn get_forest_cid_and_private_ref(
+    store: &mut impl BlockStore,
+    rng: &mut impl RngCore,
+) -> (Cid, PrivateRef) {
     // Create the private forest (a HAMT), a map-like structure where file and directory ciphertexts are stored.
     let forest = Rc::new(PrivateForest::new());
 

wnfs/src/common/blockstore.rs

@@ -41,16 +41,12 @@ pub trait BlockStore {
         self.put_block(bytes, IpldCodec::DagCbor).await
     }
 
-    async fn put_private_serializable<V, R>(
+    async fn put_private_serializable<V: Serialize>(
         &mut self,
         value: &V,
         key: &Key,
-        rng: &mut R,
-    ) -> Result<Cid>
-    where
-        V: Serialize,
-        R: RngCore,
-    {
+        rng: &mut impl RngCore,
+    ) -> Result<Cid> {
         let ipld = ipld_serde::to_ipld(value)?;
         let mut bytes = Vec::new();
         ipld.encode(DagCborCodec, &mut bytes)?;

wnfs/src/common/encoding.rs

@@ -22,9 +22,9 @@ pub mod dagcbor {
     }
 
     /// Encodes an async serializable value into DagCbor bytes.
-    pub async fn async_encode<V: AsyncSerialize, B: BlockStore>(
+    pub async fn async_encode<V: AsyncSerialize>(
         value: &V,
-        store: &mut B,
+        store: &mut impl BlockStore,
     ) -> Result<Vec<u8>> {
         let ipld = value.async_serialize_ipld(store).await?;
         let mut bytes = Vec::new();

wnfs/src/common/link.rs

@@ -55,7 +55,7 @@ impl<T> Link<T> {
     }
 
     /// Gets the value stored in link. It attempts to get it from the store if it is not present in link.
-    pub async fn resolve_value<B: BlockStore>(&self, store: &B) -> Result<&T>
+    pub async fn resolve_value<B: BlockStore + ?Sized>(&self, store: &B) -> Result<&T>
     where
         T: DeserializeOwned,
     {
@@ -123,7 +123,7 @@ impl<T> Link<T> {
     }
 
     /// Compares two links for equality. Attempts to get them from store if they are not already cached.
-    pub async fn deep_eq<B: BlockStore>(&self, other: &Link<T>, store: &mut B) -> Result<bool>
+    pub async fn deep_eq(&self, other: &Link<T>, store: &mut impl BlockStore) -> Result<bool>
     where
         T: PartialEq + AsyncSerialize,
     {
@@ -137,7 +137,7 @@ impl<T> Link<T> {
 
 #[async_trait(?Send)]
 impl<T: PartialEq + AsyncSerialize> IpldEq for Link<T> {
-    async fn eq<B: BlockStore>(&self, other: &Link<T>, store: &mut B) -> Result<bool> {
+    async fn eq<B: BlockStore + ?Sized>(&self, other: &Link<T>, store: &mut B) -> Result<bool> {
         if self == other {
             return Ok(true);
         }