Make bs wasm32 compatible (merge Comrade + Bestsign chgs)

Cargo.toml

@@ -6,6 +6,10 @@ members = [
   "crates/bs",
   "crates/bs-p2p",
   "crates/bs-traits",
+  "crates/comrade",
+  "crates/comrade-component",
+  "crates/comrade-reference",
+  "crates/bs-p2p",
   "crates/content-addressable",
   "crates/multibase",
   "crates/multicid",
@@ -32,13 +36,15 @@ license = "FSL-1.1 OR Apache-2.0"
 unexpected_cfgs = { level = "warn", check-cfg = [
   'cfg(feature, values("cargo-clippy"))',
   'cfg(fuzzing)',
-]}
+] }
 
 [workspace.dependencies]
 # Crate ependencies
 bs = { path = "crates/bs" }
 bs-p2p = { path = "crates/bs-p2p" }
 bs-traits = { path = "crates/bs-traits" }
+comrade = { path = "crates/comrade" }
+comrade-reference = { path = "crates/comrade-reference" }
 multibase = { path = "crates/multibase" }
 multicid = { path = "crates/multicid" }
 multicodec = { path = "crates/multicodec" }
@@ -60,14 +66,23 @@ rand = { version = "0.9.0", features = ["os_rng"] }
 rand_core = "0.9.3"
 rand_6 = { version = "0.6.4", package = "rand" }
 rand_core_6 = { version = "0.6.4", package = "rand_core" }
-serde = { version = "1.0.219", default-features = false, features = ["alloc", "derive"]}
-serde_cbor = { version = "0.11.2", features = ["tags"]}
-serde_json = { version = "1.0.104"}
-serde_test = { version = "1.0.104"}
+serde = { version = "1.0.219", default-features = false, features = [
+  "alloc",
+  "derive",
+] }
+serde_cbor = { version = "0.11.2", features = ["tags"] }
+serde_json = { version = "1.0.104" }
+serde_test = { version = "1.0.104" }
 sha3 = "0.10.8"
 test-log = { version = "0.2.17", features = ["trace", "color"] }
 thiserror = "2.0.12"
-tokio = { version = "1.44.2", features = ["fs", "io-util", "macros", "rt", "test-util"] }
+tokio = { version = "1.44.2", features = [
+  "fs",
+  "io-util",
+  "macros",
+  "rt",
+  "test-util",
+] }
 tracing = "0.1.41"
 tracing-subscriber = { version = "0.3.19", features = ["env-filter"] }
 unsigned-varint = { version = "0.8.0", features = ["std"] }

cli/Cargo.toml

@@ -20,6 +20,7 @@ anyhow = "1.0"
 async-trait = "0.1"
 best-practices.workspace = true
 bs.workspace = true
+bs-traits.workspace = true
 clap = { version = "4.5.36", features = ["cargo"] }
 colored = "3.0.0"
 csv = "1.3.1"
@@ -42,15 +43,15 @@ rustyline = { version = "15.0.0", features = ["derive"] }
 serde = { workspace = true, optional = true }
 serde_cbor.workspace = true
 serde_json.workspace = true
-ssh-key = { version = "0.6.2", features = ["crypto", "ed25519"]}
+ssh-key = { version = "0.6.2", features = ["crypto", "ed25519"] }
 ssh-agent-client-rs = "1.0.0"
 structopt = "0.3.26"
 thiserror.workspace = true
 tokio = { version = "1.44.2", features = ["full"] }
 toml = "0.8.20"
 tracing.workspace = true
 tracing-subscriber.workspace = true
-wacc.workspace = true
+comrade.workspace = true
 
 [dev-dependencies]
 tokio-test = "0.4.4"

cli/src/error.rs

@@ -29,6 +29,15 @@ pub enum Error {
     /// Bs errors
     #[error(transparent)]
     Bs(#[from] bs::Error),
+
+    /// Error opening a provenance log
+    #[error(transparent)]
+    Open(#[from] bs::error::OpenError),
+
+    /// Error updating a provenance log
+    #[error(transparent)]
+    Update(#[from] bs::error::UpdateError),
+
     /// Multicid error
     #[error(transparent)]
     Multicid(#[from] multicid::Error),

cli/src/subcmds/plog.rs

@@ -2,6 +2,7 @@
 
 /// Plog command
 pub mod command;
+use bs_traits::{GetKey, Signer, SyncGetKey, SyncSigner};
 pub use command::Command;
 
 use crate::{error::PlogError, Config, Error};
@@ -11,6 +12,7 @@ use bs::{
     ops::{open, update},
     update::OpParams,
 };
+use comrade::Pairs;
 use multibase::Base;
 use multicid::{Cid, EncodedCid, EncodedVlad, Vlad};
 use multicodec::Codec;
@@ -22,7 +24,54 @@ use provenance_log::{Key, Log, Script};
 use rng::StdRng;
 use std::{collections::VecDeque, convert::TryFrom, path::PathBuf};
 use tracing::debug;
-use wacc::Pairs;
+
+/// Cli KeyManager
+struct KeyManager;
+
+impl GetKey for KeyManager {
+    type Key = Multikey;
+
+    type KeyPath = Key;
+
+    type Codec = Codec;
+
+    type Error = Error;
+}
+
+impl SyncGetKey for KeyManager {
+    fn get_key(
+        &self,
+        key_path: &Self::KeyPath,
+        codec: &Self::Codec,
+        threshold: usize,
+        limit: usize,
+    ) -> Result<Self::Key, Self::Error> {
+        debug!("Generating {} key ({} of {})...", codec, threshold, limit);
+        let mut rng = StdRng::from_os_rng();
+        let mk = mk::Builder::new_from_random_bytes(*codec, &mut rng)?.try_build()?;
+        let fingerprint = mk.fingerprint_view()?.fingerprint(Codec::Blake3)?;
+
+        let ef = EncodedMultihash::new(Base::Base32Z, fingerprint);
+        debug!("Writing {} key fingerprint: {}", key_path, ef);
+        let w = writer(&Some(format!("{}.multikey", ef).into()))?;
+        serde_cbor::to_writer(w, &mk)?;
+        Ok(mk)
+    }
+}
+
+impl Signer for KeyManager {
+    type Key = Multikey;
+
+    type Signature = Multisig;
+
+    type Error = Error;
+}
+
+impl SyncSigner for KeyManager {
+    fn try_sign(&self, key: &Self::Key, data: &[u8]) -> Result<Self::Signature, Self::Error> {
+        Ok(key.sign_view()?.sign(data, false, None)?)
+    }
+}
 
 /// processes plog subcommands
 pub async fn go(cmd: Command, _config: &Config) -> Result<(), Error> {
@@ -49,29 +98,10 @@ pub async fn go(cmd: Command, _config: &Config) -> Result<(), Error> {
                 .with_entry_lock_script(&lock_script_path)
                 .with_entry_unlock_script(&unlock_script_path);
 
+            let key_manager = KeyManager;
+
             // open the p.log
-            let plog = open::open_plog(
-                cfg,
-                |key: &Key,
-                 codec: Codec,
-                 threshold: usize,
-                 limit: usize|
-                 -> Result<Multikey, bs::Error> {
-                    debug!("Generating {} key ({} of {})...", codec, threshold, limit);
-                    let mut rng = StdRng::from_os_rng();
-                    let mk = mk::Builder::new_from_random_bytes(codec, &mut rng)?.try_build()?;
-                    let fingerprint = mk.fingerprint_view()?.fingerprint(Codec::Blake3)?;
-                    let ef = EncodedMultihash::new(Base::Base32Z, fingerprint);
-                    debug!("Writing {} key fingerprint: {}", key, ef);
-                    let w = writer(&Some(format!("{}.multikey", ef).into()))?;
-                    serde_cbor::to_writer(w, &mk)?;
-                    Ok(mk)
-                },
-                |mk: &Multikey, data: &[u8]| -> Result<Multisig, bs::Error> {
-                    debug!("Signing the first entry");
-                    Ok(mk.sign_view()?.sign(data, false, None)?)
-                },
-            )?;
+            let plog = open::open_plog(cfg, &key_manager, &key_manager)?;
 
             println!("Created p.log {}", writer_name(&output)?.to_string_lossy());
             print_plog(&plog)?;
@@ -122,30 +152,10 @@ pub async fn go(cmd: Command, _config: &Config) -> Result<(), Error> {
                 .with_entry_signing_key(&entry_signing_key)
                 .with_entry_unlock_script(&unlock_script_path);
 
+            let key_manager = KeyManager;
+
             // update the p.log
-            update::update_plog(
-                &mut plog,
-                cfg,
-                |key: &Key,
-                 codec: Codec,
-                 threshold: usize,
-                 limit: usize|
-                 -> Result<Multikey, bs::Error> {
-                    debug!("Generating {} key ({} of {})...", codec, threshold, limit);
-                    let mut rng = StdRng::from_os_rng();
-                    let mk = mk::Builder::new_from_random_bytes(codec, &mut rng)?.try_build()?;
-                    let fingerprint = mk.fingerprint_view()?.fingerprint(Codec::Blake3)?;
-                    let ef = EncodedMultihash::new(Base::Base32Z, fingerprint);
-                    debug!("Writing {} key fingerprint: {}", key, ef);
-                    let w = writer(&Some(format!("{}.multikey", ef).into()))?;
-                    serde_cbor::to_writer(w, &mk)?;
-                    Ok(mk)
-                },
-                |mk: &Multikey, data: &[u8]| -> Result<Multisig, bs::Error> {
-                    debug!("Signing the first entry");
-                    Ok(mk.sign_view()?.sign(data, false, None)?)
-                },
-            )?;
+            update::update_plog(&mut plog, cfg, &key_manager, &key_manager)?;
 
             println!("Writing p.log {}", writer_name(&output)?.to_string_lossy());
             print_plog(&plog)?;
@@ -298,17 +308,17 @@ where
 }
 */
 
-fn get_from_wacc_value<'a, T>(value: &'a wacc::Value) -> Option<T>
+fn get_from_wacc_value<'a, T>(value: &'a comrade::Value) -> Option<T>
 where
     T: TryFrom<&'a [u8]> + EncodingInfo,
     BaseEncoded<T, DetectedEncoder>: TryFrom<&'a str>,
 {
     match value {
-        wacc::Value::Bin {
+        comrade::Value::Bin {
             hint: _,
             data: ref v,
         } => T::try_from(v.as_slice()).ok(),
-        wacc::Value::Str {
+        comrade::Value::Str {
             hint: _,
             data: ref s,
         } => match BaseEncoded::<T, DetectedEncoder>::try_from(s.as_str()) {

crates/bs-traits/Cargo.toml

@@ -8,7 +8,6 @@ readme = "README.md"
 license = "Functional Source License 1.1"
 
 [dependencies]
-async-trait = "0.1"
 thiserror.workspace = true
 
 [dev-dependencies]