Encoding relations API

earthstar/Cargo.toml

@@ -9,6 +9,7 @@ willow-data-model = { path = "../data-model" }
 arbitrary = { version = "1.0.2", features = ["derive"]}
 ufotofu = { version = "0.4.2", features = ["std"] }
 willow-encoding = { path = "../encoding" }
+syncify = "0.1.0"
 
 [lints]
 workspace = true

earthstar/src/cinn25519.rs

@@ -3,8 +3,6 @@ use arbitrary::{
     Arbitrary, Error as ArbitraryError,
 };
 use either::Either;
-use ufotofu::local_nb::{BulkConsumer, BulkProducer};
-use willow_encoding::{Decodable, DecodeError, Encodable};
 
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Shortname<const MIN_LENGTH: usize, const MAX_LENGTH: usize>(pub Vec<u8>);
@@ -97,94 +95,108 @@ impl<const MIN_LENGTH: usize, const MAX_LENGTH: usize> Cinn25519PublicKey<MIN_LE
     // TODO: fn verify
 }
 
-impl<const MIN_LENGTH: usize, const MAX_LENGTH: usize> Encodable
-    for Cinn25519PublicKey<MIN_LENGTH, MAX_LENGTH>
-{
-    async fn encode<Consumer>(&self, consumer: &mut Consumer) -> Result<(), Consumer::Error>
-    where
-        Consumer: BulkConsumer<Item = u8>,
+use syncify::syncify;
+use syncify::syncify_replace;
+
+#[syncify(encoding_sync)]
+pub(super) mod encoding {
+    use super::*;
+
+    #[syncify_replace(use ufotofu::sync::{BulkConsumer, BulkProducer};)]
+    use ufotofu::local_nb::{BulkConsumer, BulkProducer};
+    use willow_encoding::DecodeError;
+    #[syncify_replace(use willow_encoding::sync::{Encodable, Decodable};)]
+    use willow_encoding::{Decodable, Encodable};
+
+    impl<const MIN_LENGTH: usize, const MAX_LENGTH: usize> Encodable
+        for Cinn25519PublicKey<MIN_LENGTH, MAX_LENGTH>
     {
-        let mut vec = Vec::new();
+        async fn encode<Consumer>(&self, consumer: &mut Consumer) -> Result<(), Consumer::Error>
+        where
+            Consumer: BulkConsumer<Item = u8>,
+        {
+            let mut vec = Vec::new();
 
-        vec.extend_from_slice(&self.shortname.0);
+            vec.extend_from_slice(&self.shortname.0);
 
-        consumer
-            .bulk_consume_full_slice(&self.shortname.0)
-            .await
-            .map_err(|f| f.reason)?;
+            consumer
+                .bulk_consume_full_slice(&self.shortname.0)
+                .await
+                .map_err(|f| f.reason)?;
 
-        if MIN_LENGTH < MAX_LENGTH {
-            consumer.consume(0x0).await?;
-        }
+            if MIN_LENGTH < MAX_LENGTH {
+                consumer.consume(0x0).await?;
+            }
 
-        consumer
-            .bulk_consume_full_slice(&self.underlying)
-            .await
-            .map_err(|f| f.reason)?;
+            consumer
+                .bulk_consume_full_slice(&self.underlying)
+                .await
+                .map_err(|f| f.reason)?;
 
-        Ok(())
+            Ok(())
+        }
     }
-}
 
-impl<const MIN_LENGTH: usize, const MAX_LENGTH: usize> Decodable
-    for Cinn25519PublicKey<MIN_LENGTH, MAX_LENGTH>
-{
-    async fn decode<Producer>(
-        producer: &mut Producer,
-    ) -> Result<Self, DecodeError<<Producer>::Error>>
-    where
-        Producer: BulkProducer<Item = u8>,
+    impl<const MIN_LENGTH: usize, const MAX_LENGTH: usize> Decodable
+        for Cinn25519PublicKey<MIN_LENGTH, MAX_LENGTH>
     {
-        if MIN_LENGTH == MAX_LENGTH {
-            let mut shortname_box = vec![0; MIN_LENGTH].into_boxed_slice();
+        async fn decode<Producer>(
+            producer: &mut Producer,
+        ) -> Result<Self, DecodeError<<Producer>::Error>>
+        where
+            Producer: BulkProducer<Item = u8>,
+        {
+            if MIN_LENGTH == MAX_LENGTH {
+                let mut shortname_box = vec![0; MIN_LENGTH].into_boxed_slice();
+
+                producer
+                    .bulk_overwrite_full_slice(shortname_box.as_mut())
+                    .await?;
+
+                let mut underlying_slice = [0u8; 32];
+
+                producer
+                    .bulk_overwrite_full_slice(&mut underlying_slice)
+                    .await?;
+
+                return Ok(Self {
+                    shortname: Shortname(shortname_box.into()),
+                    underlying: underlying_slice,
+                });
+            }
 
-            producer
-                .bulk_overwrite_full_slice(shortname_box.as_mut())
-                .await?;
+            let mut shortname_vec: Vec<u8> = Vec::new();
+
+            loop {
+                match producer.produce().await {
+                    Ok(Either::Left(item)) => {
+                        // if item is 0x0, stop
+                        if item == 0x0 {
+                            break;
+                        }
+
+                        shortname_vec.push(item);
+                    }
+                    Ok(Either::Right(_)) => {
+                        // whatever happens, we won't be able to make a full public key.
+                        // Error!
+                        return Err(DecodeError::InvalidInput);
+                    }
+                    Err(err) => return Err(DecodeError::Producer(err)),
+                }
+            }
 
             let mut underlying_slice = [0u8; 32];
 
             producer
                 .bulk_overwrite_full_slice(&mut underlying_slice)
                 .await?;
 
-            return Ok(Self {
-                shortname: Shortname(shortname_box.into()),
+            Ok(Self {
+                shortname: Shortname(shortname_vec),
                 underlying: underlying_slice,
-            });
+            })
         }
-
-        let mut shortname_vec: Vec<u8> = Vec::new();
-
-        loop {
-            match producer.produce().await {
-                Ok(Either::Left(item)) => {
-                    // if item is 0x0, stop
-                    if item == 0x0 {
-                        break;
-                    }
-
-                    shortname_vec.push(item);
-                }
-                Ok(Either::Right(_)) => {
-                    // whatever happens, we won't be able to make a full public key.
-                    // Error!
-                    return Err(DecodeError::InvalidInput);
-                }
-                Err(err) => return Err(DecodeError::Producer(err)),
-            }
-        }
-
-        let mut underlying_slice = [0u8; 32];
-
-        producer
-            .bulk_overwrite_full_slice(&mut underlying_slice)
-            .await?;
-
-        Ok(Self {
-            shortname: Shortname(shortname_vec),
-            underlying: underlying_slice,
-        })
     }
 }
 

earthstar/src/identity_id.rs

@@ -1,9 +1,6 @@
+use crate::cinn25519::{Cinn25519PublicKey, Shortname};
 use arbitrary::Arbitrary;
-use ufotofu::local_nb::{BulkConsumer, BulkProducer};
 use willow_data_model::SubspaceId;
-use willow_encoding::{Decodable, DecodeError, Encodable};
-
-use crate::cinn25519::{Cinn25519PublicKey, Shortname};
 
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Arbitrary)]
 pub struct IdentityIdentifier(Cinn25519PublicKey<4, 4>);
@@ -17,24 +14,38 @@ impl Default for IdentityIdentifier {
     }
 }
 
-impl Encodable for IdentityIdentifier {
-    async fn encode<C>(&self, consumer: &mut C) -> Result<(), C::Error>
-    where
-        C: BulkConsumer<Item = u8>,
-    {
-        self.0.encode(consumer).await?;
-        Ok(())
+use syncify::syncify;
+use syncify::syncify_replace;
+
+#[syncify(encoding_sync)]
+pub(super) mod encoding {
+    use super::*;
+
+    #[syncify_replace(use ufotofu::sync::{BulkConsumer, BulkProducer};)]
+    use ufotofu::local_nb::{BulkConsumer, BulkProducer};
+    use willow_encoding::DecodeError;
+    #[syncify_replace(use willow_encoding::sync::{Encodable, Decodable};)]
+    use willow_encoding::{Decodable, Encodable};
+
+    impl Encodable for IdentityIdentifier {
+        async fn encode<C>(&self, consumer: &mut C) -> Result<(), C::Error>
+        where
+            C: BulkConsumer<Item = u8>,
+        {
+            self.0.encode(consumer).await?;
+            Ok(())
+        }
     }
-}
 
-impl Decodable for IdentityIdentifier {
-    async fn decode<P>(producer: &mut P) -> Result<Self, DecodeError<P::Error>>
-    where
-        P: BulkProducer<Item = u8>,
-    {
-        match Cinn25519PublicKey::decode(producer).await {
-            Ok(pk) => Ok(Self(pk)),
-            Err(err) => Err(err),
+    impl Decodable for IdentityIdentifier {
+        async fn decode<P>(producer: &mut P) -> Result<Self, DecodeError<P::Error>>
+        where
+            P: BulkProducer<Item = u8>,
+        {
+            match Cinn25519PublicKey::decode(producer).await {
+                Ok(pk) => Ok(Self(pk)),
+                Err(err) => Err(err),
+            }
         }
     }
 }

earthstar/src/namespace_id.rs

@@ -1,7 +1,6 @@
 use arbitrary::Arbitrary;
-use ufotofu::local_nb::{BulkConsumer, BulkProducer};
+
 use willow_data_model::NamespaceId;
-use willow_encoding::{Decodable, DecodeError, Encodable};
 
 use crate::cinn25519::{Cinn25519PublicKey, Shortname};
 
@@ -17,24 +16,38 @@ impl Default for NamespaceIdentifier {
     }
 }
 
-impl Encodable for NamespaceIdentifier {
-    async fn encode<C>(&self, consumer: &mut C) -> Result<(), C::Error>
-    where
-        C: BulkConsumer<Item = u8>,
-    {
-        self.0.encode(consumer).await?;
-        Ok(())
+use syncify::syncify;
+use syncify::syncify_replace;
+
+#[syncify(encoding_sync)]
+pub(super) mod encoding {
+    use super::*;
+
+    #[syncify_replace(use ufotofu::sync::{BulkConsumer, BulkProducer};)]
+    use ufotofu::local_nb::{BulkConsumer, BulkProducer};
+    use willow_encoding::DecodeError;
+    #[syncify_replace(use willow_encoding::sync::{Encodable, Decodable};)]
+    use willow_encoding::{Decodable, Encodable};
+
+    impl Encodable for NamespaceIdentifier {
+        async fn encode<C>(&self, consumer: &mut C) -> Result<(), C::Error>
+        where
+            C: BulkConsumer<Item = u8>,
+        {
+            self.0.encode(consumer).await?;
+            Ok(())
+        }
     }
-}
 
-impl Decodable for NamespaceIdentifier {
-    async fn decode<P>(producer: &mut P) -> Result<Self, DecodeError<<P>::Error>>
-    where
-        P: BulkProducer<Item = u8>,
-    {
-        match Cinn25519PublicKey::decode(producer).await {
-            Ok(pk) => Ok(Self(pk)),
-            Err(err) => Err(err),
+    impl Decodable for NamespaceIdentifier {
+        async fn decode<P>(producer: &mut P) -> Result<Self, DecodeError<<P>::Error>>
+        where
+            P: BulkProducer<Item = u8>,
+        {
+            match Cinn25519PublicKey::decode(producer).await {
+                Ok(pk) => Ok(Self(pk)),
+                Err(err) => Err(err),
+            }
         }
     }
 }

encoding/src/compact_width.rs

@@ -148,7 +148,23 @@ pub mod encoding {
         Ok(())
     }
 
+    /// Decode the bytes representing a [`CompactWidth`]-bytes integer into a `usize` as encoding relation.
+    pub async fn decode_relation_compact_width_be<Producer: BulkProducer<Item = u8>>(
+        compact_width: CompactWidth,
+        producer: &mut Producer,
+    ) -> Result<u64, DecodeError<Producer::Error>> {
+        let decoded = match compact_width {
+            CompactWidth::One => U8BE::decode(producer).await.map(u64::from),
+            CompactWidth::Two => U16BE::decode(producer).await.map(u64::from),
+            CompactWidth::Four => U32BE::decode(producer).await.map(u64::from),
+            CompactWidth::Eight => U64BE::decode(producer).await.map(u64::from),
+        }?;
+
+        Ok(decoded)
+    }
+
     /// Decode the bytes representing a [`CompactWidth`]-bytes integer into a `usize`.
+    /// Will fail if the decoded value could have been encoded with a smaller [`CompactWidth`].
     pub async fn decode_compact_width_be<Producer: BulkProducer<Item = u8>>(
         compact_width: CompactWidth,
         producer: &mut Producer,