diff --git a/Cargo.toml b/Cargo.toml
index cc5aba0..034a833 100644
--- a/Cargo.toml
+++ b/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"] }
diff --git a/cli/Cargo.toml b/cli/Cargo.toml
index 8db8101..07fa020 100644
--- a/cli/Cargo.toml
+++ b/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,7 +43,7 @@ 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
@@ -50,7 +51,7 @@ 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"
diff --git a/cli/src/error.rs b/cli/src/error.rs
index 18783df..e809ad4 100644
--- a/cli/src/error.rs
+++ b/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),
diff --git a/cli/src/subcmds/plog.rs b/cli/src/subcmds/plog.rs
index 486618a..fe167e3 100644
--- a/cli/src/subcmds/plog.rs
+++ b/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()) {
diff --git a/crates/bs-traits/Cargo.toml b/crates/bs-traits/Cargo.toml
index b13b8aa..66f51fc 100644
--- a/crates/bs-traits/Cargo.toml
+++ b/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]
diff --git a/crates/bs-traits/src/async.rs b/crates/bs-traits/src/async.rs
index 9dc7211..0323105 100644
--- a/crates/bs-traits/src/async.rs
+++ b/crates/bs-traits/src/async.rs
@@ -1,107 +1,141 @@
 // SPDX-License-Identifier: FSL-1.1
-
+//! This module provides traits for asynchronous operations
+use crate::cond_send::{CondSend, CondSync};
 use crate::*;
-use async_trait::*;
+use std::future::Future;
 use std::num::NonZeroUsize;
 
 /// Trait for types that can sign data asynchronously
-#[async_trait]
 pub trait AsyncSigner: Signer {
     /// Attempt to sign the data asynchronously
-    async fn try_sign_async(&self, key: &Self::Key, data: &[u8]) -> Result<Self::Signature, Error>;
+    fn try_sign(
+        &self,
+        key: &Self::Key,
+        data: &[u8],
+    ) -> impl Future<Output = Result<Self::Signature, Self::Error>> + CondSend + '_;
 
     /// Sign the data asynchronously
-    async fn sign_async(&self, key: &Self::Key, data: &[u8]) -> Self::Signature {
-        self.try_sign_async(key, data)
-            .await
-            .expect("signing operation failed")
+    ///
+    /// # Panics
+    ///
+    /// This function will panic if the signing operation fails.
+    fn sign<'a>(
+        &'a self,
+        key: &'a Self::Key,
+        data: &'a [u8],
+    ) -> impl Future<Output = Self::Signature> + CondSend + 'a
+    where
+        Self: CondSync,
+        Self::Key: CondSync,
+    {
+        async move {
+            self.try_sign(key, data)
+                .await
+                .expect("signing operation failed")
+        }
     }
 }
 
 /// Trait for types that can verify data asynchronously
-#[async_trait]
 pub trait AsyncVerifier: Verifier {
     /// Verify the data asynchronously
-    async fn verify_async(
+    fn verify(
         &self,
         key: &Self::Key,
         data: &[u8],
         signature: &Self::Signature,
-    ) -> Result<(), Error>;
+    ) -> impl Future<Output = Result<(), Self::Error>> + CondSend + '_;
 }
 
 /// Trait for types that can encrypt data asynchronously
-#[async_trait]
 pub trait AsyncEncryptor: Encryptor {
     /// Attempt to encrypt the data asynchronously
-    async fn try_encrypt_async(
+    fn try_encrypt(
         &self,
         key: &Self::Key,
         plaintext: &Self::Plaintext,
-    ) -> Result<Self::Ciphertext, Error>;
+    ) -> impl Future<Output = Result<Self::Ciphertext, Self::Error>> + CondSend + '_;
 
     /// Encrypt the data asynchronously
-    async fn encrypt_async(
-        &self,
-        key: &Self::Key,
-        plaintext: &Self::Plaintext,
-    ) -> Self::Ciphertext {
-        self.try_encrypt_async(key, plaintext)
-            .await
-            .expect("encryption operation failed")
+    ///
+    /// # Panics
+    ///
+    /// This function will panic if the encryption operation fails.
+    fn encrypt<'a>(
+        &'a self,
+        key: &'a Self::Key,
+        plaintext: &'a Self::Plaintext,
+    ) -> impl Future<Output = Self::Ciphertext> + CondSend + 'a
+    where
+        Self: CondSync,
+        Self::Key: CondSync,
+        Self::Plaintext: CondSync,
+    {
+        async move {
+            self.try_encrypt(key, plaintext)
+                .await
+                .expect("encryption operation failed")
+        }
     }
 }
 
 /// Trait for types that can decrypt data asynchronously
-#[async_trait]
 pub trait AsyncDecryptor: Decryptor {
     /// Decrypt the data asynchronously
-    async fn decrypt_async(
+    fn decrypt(
         &self,
         key: &Self::Key,
         ciphertext: &Self::Ciphertext,
-    ) -> Result<Self::Plaintext, Error>;
+    ) -> impl Future<Output = Result<Self::Plaintext, Self::Error>> + CondSend + '_;
 }
 
 /// Trait for types that can split a secret into shares asynchronously
-#[async_trait]
 pub trait AsyncSecretSplitter: SecretSplitter {
     /// Split the secret into shares asynchronously
-    async fn split_async(
+    ///
+    /// Conditions for `split` to succeed:
+    /// - Threshold must be less than or equal to limit.
+    /// - Threshold must be greater than or equal to 2.
+    fn split(
         &self,
         secret: &Self::Secret,
         threshold: NonZeroUsize,
         limit: NonZeroUsize,
-    ) -> Result<Self::Output, Error>;
+    ) -> impl Future<Output = Result<Self::Output, Self::Error>> + CondSend + '_;
 
     /// Split the secret into shares with the given identifiers asynchronously
-    async fn split_with_identifiers_async(
+    /// The number of shares will be equal to the number of identifiers i.e. the `limit`.
+    ///
+    /// Conditions for `split_with_identifiers` to succeed:
+    /// - Threshold must be less than or equal to the number of identifiers.
+    /// - Threshold must be greater than or equal to 2.
+    /// - Identifiers must be unique.
+    /// - Identifiers must not be empty.
+    fn split_with_identifiers(
         &self,
         secret: &Self::Secret,
         threshold: NonZeroUsize,
         identifiers: &[Self::Identifier],
-    ) -> Result<Self::Output, Error>;
+    ) -> impl Future<Output = Result<Self::Output, Self::Error>> + CondSend + '_;
 }
 
 /// Trait for types that can combine shares into a secret asynchronously
-#[async_trait]
 pub trait AsyncSecretCombiner: SecretCombiner {
     /// Combine the shares into a secret asynchronously
-    async fn combine_async(
+    fn combine(
         &self,
         shares: &[(Self::Identifier, Self::Shares)],
-    ) -> Result<Self::Secret, Error>;
+    ) -> impl Future<Output = Result<Self::Secret, Self::Error>> + CondSend + '_;
 }
 
 /// Trait for types that can get a key asynchronously
-#[async_trait]
 pub trait AsyncGetKey: GetKey {
     /// Get the key asynchronously
-    async fn get_key_async(
+    fn get_key(
         &self,
         key_path: &Self::KeyPath,
         codec: &Self::Codec,
         threshold: usize,
         limit: usize,
-    ) -> Result<Self::Key, Error>;
+    ) -> impl Future<Output = Result<Self::Key, Self::Error>> + CondSend + '_;
 }
diff --git a/crates/bs-traits/src/cond_send.rs b/crates/bs-traits/src/cond_send.rs
new file mode 100644
index 0000000..df30005
--- /dev/null
+++ b/crates/bs-traits/src/cond_send.rs
@@ -0,0 +1,33 @@
+//! Utilities for conditionally adding `Send` and `Sync` constraints.
+
+/// A conditionally compiled trait indirection for `Send` bounds.
+/// This target makes it require `Send`.
+#[cfg(not(target_arch = "wasm32"))]
+pub trait CondSend: Send {}
+
+/// A conditionally compiled trait indirection for `Send` bounds.
+/// This target makes it not require any marker traits.
+#[cfg(target_arch = "wasm32")]
+pub trait CondSend {}
+
+#[cfg(not(target_arch = "wasm32"))]
+impl<S> CondSend for S where S: Send {}
+
+#[cfg(target_arch = "wasm32")]
+impl<S> CondSend for S {}
+
+/// A conditionally compiled trait indirection for `Send + Sync` bounds.
+/// This target makes it require `Send + Sync`.
+#[cfg(not(target_arch = "wasm32"))]
+pub trait CondSync: Send + Sync {}
+
+/// A conditionally compiled trait indirection for `Send + Sync` bounds.
+/// This target makes it not require any marker traits.
+#[cfg(target_arch = "wasm32")]
+pub trait CondSync {}
+
+#[cfg(not(target_arch = "wasm32"))]
+impl<S> CondSync for S where S: Send + Sync {}
+
+#[cfg(target_arch = "wasm32")]
+impl<S> CondSync for S {}
diff --git a/crates/bs-traits/src/lib.rs b/crates/bs-traits/src/lib.rs
index d74ab8b..c6ef5b3 100644
--- a/crates/bs-traits/src/lib.rs
+++ b/crates/bs-traits/src/lib.rs
@@ -5,6 +5,7 @@
 /// It also provides a `WaitQueue` type that can be used to implement synchronous and asynchronous operations
 /// without having to use tokio::block_in_place or similar.
 mod r#async;
+mod cond_send;
 mod error;
 mod sync;
 mod wait_queue;
@@ -13,3 +14,89 @@ pub use error::Error;
 pub use r#async::*;
 pub use sync::*;
 pub use wait_queue::*;
+
+use std::fmt::Debug;
+
+/// Trait for types that can sign data using [AsyncSigner] or [SyncSigner]
+pub trait Signer {
+    /// The type of key used to sign
+    type Key;
+    /// The type of signature
+    type Signature;
+    /// Any Signing Error
+    type Error: Debug;
+}
+
+/// Trait for types that can verify signatures using [AsyncVerifier] or [SyncVerifier]
+pub trait Verifier {
+    /// The type of key used to verify
+    type Key;
+    /// The type of signature
+    type Signature;
+    /// Error type for verification operations
+    type Error;
+}
+
+/// Trait for types that can encrypt data using [AsyncEncryptor] or [SyncEncryptor]
+pub trait Encryptor {
+    /// The type of key used to encrypt
+    type Key: Send + Sync;
+    /// The type of ciphertext
+    type Ciphertext: Send + Sync;
+    /// The type of plaintext, might include the nonce, and additional authenticated data
+    type Plaintext: Send + Sync;
+    /// Error type for encryption operations
+    type Error: Debug;
+}
+
+/// Trait for types that can decrypt data using [AsyncDecryptor] or [SyncDecryptor]
+pub trait Decryptor {
+    /// The type of key used to decrypt
+    type Key: Send + Sync;
+    /// The type of ciphertext
+    type Ciphertext: Send + Sync;
+    /// The type of plaintext
+    type Plaintext: Send + Sync;
+    /// Error type for decryption operations
+    type Error;
+}
+
+/// Trait for types that can split a secret into shares, using [AsyncSecretSplitter] or [SyncSecretSplitter]
+pub trait SecretSplitter {
+    /// The type of secret to split
+    type Secret: Send + Sync;
+    /// The type of identifier for the shares
+    type Identifier: Send + Sync;
+    /// The output from splitting the secret.
+    /// Might include the threshold and limit used to split the secret,
+    /// the shares, and the verifiers, identifiers,
+    /// or any other information needed to reconstruct the secret
+    /// and verify the shares.
+    type Output: Send + Sync;
+    /// Error type for secret splitting operations
+    type Error;
+}
+
+/// Trait for types that can combine shares into a secret, using [AsyncSecretCombiner] or [SyncSecretCombiner]
+pub trait SecretCombiner {
+    /// The type of secret to combine
+    type Secret: Send + Sync;
+    /// The type of identifier for the shares
+    type Identifier: Send + Sync;
+    /// The type of shares to combine
+    type Shares: Send + Sync;
+    /// Error type for secret combining operations
+    type Error;
+}
+
+/// Trait for types that can retrieve a key, using [AsyncGetKey] or [SyncGetKey]
+pub trait GetKey {
+    /// The type of key
+    type Key;
+    /// The type of key path
+    type KeyPath;
+    /// The type of codec
+    type Codec;
+    /// The Error returned
+    type Error;
+}
diff --git a/crates/bs-traits/src/sync.rs b/crates/bs-traits/src/sync.rs
index d0916f8..ac56561 100644
--- a/crates/bs-traits/src/sync.rs
+++ b/crates/bs-traits/src/sync.rs
@@ -1,54 +1,42 @@
+//! This module contains traits for synchronous operations.
 use core::num::NonZeroUsize;
 
-use crate::Error;
+use crate::*;
 
 /// Trait for types that can sign data
-pub trait Signer {
-    /// The type of key used to sign
-    type Key: Send + Sync;
-    /// The type of signature
-    type Signature: Send + Sync;
-
+pub trait SyncSigner: Signer {
     /// Attempt to sign the data
-    fn try_sign(&self, key: &Self::Key, data: &[u8]) -> Result<Self::Signature, Error>;
+    fn try_sign(&self, key: &Self::Key, data: &[u8]) -> Result<Self::Signature, Self::Error>;
 
     /// Sign the data and return the signature
+    ///
+    /// # Panics
+    ///
+    /// This function will panic if the signing operation fails.
     fn sign(&self, key: &Self::Key, data: &[u8]) -> Self::Signature {
         self.try_sign(key, data).expect("signing operation failed")
     }
 }
 
 /// Trait for types that can verify signatures
-pub trait Verifier {
-    /// The type of key used to verify
-    type Key: Send + Sync;
-    /// The type of signature
-    type Signature: Send + Sync;
-
+pub trait SyncVerifier: Verifier {
     /// Verify that the provided signature for the given data is authentic
     fn verify(
         &self,
         key: &Self::Key,
         data: &[u8],
         signature: &Self::Signature,
-    ) -> Result<(), Error>;
+    ) -> Result<(), Self::Error>;
 }
 
 /// Trait for types that can encrypt data
-pub trait Encryptor {
-    /// The type of key used to encrypt
-    type Key: Send + Sync;
-    /// The type of ciphertext
-    type Ciphertext: Send + Sync;
-    /// The type of plaintext, might include the nonce, and additional authenticated data
-    type Plaintext: Send + Sync;
-
+pub trait SyncEncryptor: Encryptor {
     /// Attempt to encrypt the plaintext
     fn try_encrypt(
         &self,
         key: &Self::Key,
         plaintext: &Self::Plaintext,
-    ) -> Result<Self::Ciphertext, Error>;
+    ) -> Result<Self::Ciphertext, Self::Error>;
 
     /// Encrypt the plaintext
     fn encrypt(&self, key: &Self::Key, plaintext: &Self::Plaintext) -> Self::Ciphertext {
@@ -58,35 +46,17 @@ pub trait Encryptor {
 }
 
 /// Trait for types that can decrypt data
-pub trait Decryptor {
-    /// The type of key used to decrypt
-    type Key: Send + Sync;
-    /// The type of ciphertext
-    type Ciphertext: Send + Sync;
-    /// The type of plaintext
-    type Plaintext: Send + Sync;
-
+pub trait SyncDecryptor: Decryptor {
     /// Attempt to decrypt the ciphertext
     fn decrypt(
         &self,
         key: &Self::Key,
         ciphertext: &Self::Ciphertext,
-    ) -> Result<Self::Plaintext, Error>;
+    ) -> Result<Self::Plaintext, Self::Error>;
 }
 
 /// Trait for types that can split a secret into shares
-pub trait SecretSplitter {
-    /// The type of secret to split
-    type Secret: Send + Sync;
-    /// The type of identifier for the shares
-    type Identifier: Send + Sync;
-    /// The output from splitting the secret.
-    /// Might include the threshold and limit used to split the secret,
-    /// the shares, and the verifiers, identifiers,
-    /// or any other information needed to reconstruct the secret
-    /// and verify the shares.
-    type Output: Send + Sync;
-
+pub trait SyncSecretSplitter: SecretSplitter {
     /// Split the secret into shares.
     ///
     /// Conditions for `split` to succeed:
@@ -97,7 +67,7 @@ pub trait SecretSplitter {
         secret: &Self::Secret,
         threshold: NonZeroUsize,
         limit: NonZeroUsize,
-    ) -> Result<Self::Output, Error>;
+    ) -> Result<Self::Output, Self::Error>;
 
     /// Split the secret into shares with the given identifiers.
     /// The number of shares will be equal to the number of identifiers i.e. the `limit`.
@@ -112,31 +82,20 @@ pub trait SecretSplitter {
         secret: &Self::Secret,
         threshold: NonZeroUsize,
         identifiers: &[Self::Identifier],
-    ) -> Result<Self::Output, Error>;
+    ) -> Result<Self::Output, Self::Error>;
 }
 
 /// Trait for types that can combine shares into a secret
-pub trait SecretCombiner {
-    /// The type of secret to combine
-    type Secret: Send + Sync;
-    /// The type of identifier for the shares
-    type Identifier: Send + Sync;
-    /// The type of shares to combine
-    type Shares: Send + Sync;
-
+pub trait SyncSecretCombiner: SecretCombiner {
     /// Combine the shares into a secret
-    fn combine(&self, shares: &[(Self::Identifier, Self::Shares)]) -> Result<Self::Secret, Error>;
+    fn combine(
+        &self,
+        shares: &[(Self::Identifier, Self::Shares)],
+    ) -> Result<Self::Secret, Self::Error>;
 }
 
 /// Trait for types that can retrieve a key
-pub trait GetKey {
-    /// The type of key
-    type Key: Send + Sync;
-    /// The type of key path
-    type KeyPath: Send + Sync;
-    /// The type of codec
-    type Codec: Send + Sync;
-
+pub trait SyncGetKey: GetKey {
     /// Get the key
     fn get_key(
         &self,
@@ -144,5 +103,5 @@ pub trait GetKey {
         codec: &Self::Codec,
         threshold: usize,
         limit: usize,
-    ) -> Result<Self::Key, Error>;
+    ) -> Result<Self::Key, Self::Error>;
 }
diff --git a/crates/bs/Cargo.toml b/crates/bs/Cargo.toml
index a575852..ee01f8a 100644
--- a/crates/bs/Cargo.toml
+++ b/crates/bs/Cargo.toml
@@ -17,10 +17,8 @@ multikey.workspace = true
 multisig.workspace = true
 provenance-log.workspace = true
 rand.workspace = true
-serde_cbor.workspace = true
 thiserror.workspace = true
 tracing.workspace = true
-wacc.workspace = true
 
 [lints]
 workspace = true
diff --git a/crates/bs/src/error.rs b/crates/bs/src/error.rs
index fe72900..bb9a2a3 100644
--- a/crates/bs/src/error.rs
+++ b/crates/bs/src/error.rs
@@ -39,9 +39,6 @@ pub enum Error {
     /// I/O error
     #[error(transparent)]
     Io(#[from] std::io::Error),
-    /// Serde CBOR error
-    #[error(transparent)]
-    SerdeCbor(#[from] serde_cbor::Error),
 }
 
 /// Open op errors
diff --git a/crates/bs/src/ops/open.rs b/crates/bs/src/ops/open.rs
index 3b0bc5b..d673cf1 100644
--- a/crates/bs/src/ops/open.rs
+++ b/crates/bs/src/ops/open.rs
@@ -7,9 +7,8 @@ pub use config::Config;
 use crate::{
     error::OpenError,
     update::{op, script, OpParams},
-    Error,
 };
-use bs_traits::{GetKey, Signer};
+use bs_traits::{GetKey, Signer, SyncGetKey, SyncSigner};
 use multicid::{cid, vlad, Cid};
 use multicodec::Codec;
 use multihash::mh;
@@ -20,10 +19,18 @@ use std::{fs::read, path::Path};
 use tracing::debug;
 
 /// open a new provenance log based on the config
-pub fn open_plog<G, S>(config: Config, get_key: &G, sign_entry: &S) -> Result<Log, Error>
+pub fn open_plog<G, S, E>(config: Config, key_manager: &G, signer: &S) -> Result<Log, E>
 where
-    G: GetKey<Key = Multikey, KeyPath = Key, Codec = Codec>,
-    S: Signer<Key = Multikey, Signature = Multisig>,
+    G: GetKey<KeyPath = Key, Codec = Codec, Key = Multikey, Error = E> + SyncGetKey,
+    S: Signer<Key = Multikey, Signature = Multisig, Error = E> + SyncSigner,
+    E: From<OpenError>
+        + From<PlogError>
+        + From<std::io::Error>
+        + From<multicid::Error>
+        + From<multikey::Error>
+        + From<multihash::Error>
+        + From<crate::Error>
+        + ToString,
 {
     // 0. Set up the list of ops we're going to add
     let mut op_params = Vec::default();
@@ -33,14 +40,14 @@ where
     config
         .additional_ops
         .iter()
-        .try_for_each(|params| -> Result<(), Error> {
+        .try_for_each(|params| -> Result<(), E> {
             match params {
                 p @ OpParams::KeyGen { .. } => {
-                    let _ = load_key(&mut op_params, p, get_key)?;
+                    let _ = load_key(&mut op_params, p, key_manager)?;
                 }
                 p @ OpParams::CidGen { .. } => {
-                    let _ = load_cid(&mut op_params, p, |path| -> Result<Vec<u8>, Error> {
-                        Ok(read(path)?)
+                    let _ = load_cid(&mut op_params, p, |path| -> Result<Vec<u8>, E> {
+                        read(path).map_err(E::from)
                     })?;
                 }
                 p => op_params.push(p.clone()),
@@ -53,15 +60,15 @@ where
     // get the codec for the vlad signing key and cid
     let (vlad_key_params, vlad_cid_params) = config
         .vlad_params
-        .ok_or::<Error>(OpenError::InvalidVladParams.into())?;
+        .ok_or::<E>(OpenError::InvalidVladParams.into())?;
     // get the vlad signing key
-    let vlad_mk = load_key(&mut op_params, &vlad_key_params, get_key)?;
+    let vlad_mk = load_key(&mut op_params, &vlad_key_params, key_manager)?;
     // get the cid for the first lock script
     let mut first_lock_script: Option<Script> = None;
     let cid = load_cid(
         &mut op_params,
         &vlad_cid_params,
-        |path| -> Result<Vec<u8>, Error> {
+        |path| -> Result<Vec<u8>, E> {
             // this is a script so load the file that way
             let script = script::Loader::new(path).try_build()?;
             first_lock_script = Some(script.clone());
@@ -80,24 +87,24 @@ where
     // get the params for the entry signing key
     let entrykey_params = config
         .entrykey_params
-        .ok_or::<Error>(OpenError::InvalidKeyParams.into())?;
+        .ok_or::<E>(OpenError::InvalidKeyParams.into())?;
 
     // get the entry signing key
-    let entry_mk = load_key(&mut op_params, &entrykey_params, get_key)?;
+    let entry_mk = load_key(&mut op_params, &entrykey_params, key_manager)?;
 
     // get the params for the pubkey
     let pubkey_params = config
         .pubkey_params
-        .ok_or::<Error>(OpenError::InvalidKeyParams.into())?;
+        .ok_or::<E>(OpenError::InvalidKeyParams.into())?;
 
     // get the pubkey
-    let _ = load_key(&mut op_params, &pubkey_params, get_key)?;
+    let _ = load_key(&mut op_params, &pubkey_params, key_manager)?;
 
     // load the entry lock script
     let lock_script = {
         let lock_path = config
             .entry_lock_script
-            .ok_or::<Error>(OpenError::NoEntryLockScript.into())?;
+            .ok_or::<E>(OpenError::NoEntryLockScript.into())?;
         script::Loader::new(lock_path).try_build()?
     };
 
@@ -105,7 +112,7 @@ where
     let unlock_script = {
         let unlock_path = config
             .entry_unlock_script
-            .ok_or::<Error>(OpenError::NoEntryUnlockScript.into())?;
+            .ok_or::<E>(OpenError::NoEntryUnlockScript.into())?;
         script::Loader::new(unlock_path).try_build()?
     };
 
@@ -118,52 +125,50 @@ where
         .with_unlock(&unlock_script);
 
     // add in all of the entry Ops
-    op_params
-        .iter()
-        .try_for_each(|params| -> Result<(), Error> {
-            // construct the op
-            let op = match params {
-                OpParams::Noop { key } => op::Builder::new(OpId::Noop)
-                    .with_key_path(key)
-                    .try_build()?,
-                OpParams::Delete { key } => op::Builder::new(OpId::Delete)
-                    .with_key_path(key)
-                    .try_build()?,
-                OpParams::UseCid { key, cid } => {
-                    let v: Vec<u8> = cid.clone().into();
-                    op::Builder::new(OpId::Update)
-                        .with_key_path(key)
-                        .with_data_value(v)
-                        .try_build()?
-                }
-                OpParams::UseKey { key, mk } => {
-                    let v: Vec<u8> = mk.clone().into();
-                    op::Builder::new(OpId::Update)
-                        .with_key_path(key)
-                        .with_data_value(v)
-                        .try_build()?
-                }
-                OpParams::UseStr { key, s } => op::Builder::new(OpId::Update)
+    op_params.iter().try_for_each(|params| -> Result<(), E> {
+        // construct the op
+        let op = match params {
+            OpParams::Noop { key } => op::Builder::new(OpId::Noop)
+                .with_key_path(key)
+                .try_build()?,
+            OpParams::Delete { key } => op::Builder::new(OpId::Delete)
+                .with_key_path(key)
+                .try_build()?,
+            OpParams::UseCid { key, cid } => {
+                let v: Vec<u8> = cid.clone().into();
+                op::Builder::new(OpId::Update)
                     .with_key_path(key)
-                    .with_string_value(s)
-                    .try_build()?,
-                OpParams::UseBin { key, data } => op::Builder::new(OpId::Update)
+                    .with_data_value(v)
+                    .try_build()?
+            }
+            OpParams::UseKey { key, mk } => {
+                let v: Vec<u8> = mk.clone().into();
+                op::Builder::new(OpId::Update)
                     .with_key_path(key)
-                    .with_data_value(data)
-                    .try_build()?,
-                _ => return Err(OpenError::InvalidOpParams.into()),
-            };
-            // add the op to the builder
-            builder = builder.clone().add_op(&op);
-            Ok(())
-        })?;
+                    .with_data_value(v)
+                    .try_build()?
+            }
+            OpParams::UseStr { key, s } => op::Builder::new(OpId::Update)
+                .with_key_path(key)
+                .with_string_value(s)
+                .try_build()?,
+            OpParams::UseBin { key, data } => op::Builder::new(OpId::Update)
+                .with_key_path(key)
+                .with_data_value(data)
+                .try_build()?,
+            _ => return Err(OpenError::InvalidOpParams.into()),
+        };
+        // add the op to the builder
+        builder = builder.clone().add_op(&op);
+        Ok(())
+    })?;
 
     // finalize the entry building by signing it
     let entry = builder.try_build(|e| {
         // get the serialzied version of the entry with an empty "proof" field
         let ev: Vec<u8> = e.clone().into();
         // call the call back to have the caller sign the data
-        let ms = sign_entry
+        let ms = signer
             .try_sign(&entry_mk, &ev)
             .map_err(|e| PlogError::from(EntryError::SignFailed(e.to_string())))?;
         // store the signature as proof
@@ -174,16 +179,18 @@ where
 
     let log = provenance_log::log::Builder::new()
         .with_vlad(&vlad)
-        .with_first_lock(&first_lock_script.ok_or::<Error>(OpenError::NoFirstLockScript.into())?)
+        .with_first_lock(&first_lock_script.ok_or::<E>(OpenError::NoFirstLockScript.into())?)
         .append_entry(&entry)
         .try_build()?;
 
     Ok(log)
 }
 
-fn load_key<G>(ops: &mut Vec<OpParams>, params: &OpParams, get_key: &G) -> Result<Multikey, Error>
+fn load_key<G, E>(ops: &mut Vec<OpParams>, params: &OpParams, key_manager: &G) -> Result<G::Key, E>
 where
-    G: GetKey<Key = Multikey, KeyPath = Key, Codec = Codec>,
+    G: GetKey<Error = E, KeyPath = Key, Codec = Codec> + SyncGetKey,
+    G::Key: Into<Vec<u8>> + Clone + Views,
+    E: From<OpenError> + From<multikey::Error>,
 {
     debug!("load_key: {:?}", params);
     match params {
@@ -195,7 +202,7 @@ where
             revoke,
         } => {
             // call back to generate the key
-            let mk = get_key.get_key(key, codec, *threshold, *limit)?;
+            let mk = key_manager.get_key(key, codec, *threshold, *limit)?;
 
             // get the public key
             let pk = mk.conv_view()?.to_public_key()?;
@@ -217,9 +224,10 @@ where
     }
 }
 
-fn load_cid<F>(ops: &mut Vec<OpParams>, params: &OpParams, load_file: F) -> Result<Cid, Error>
+fn load_cid<F, E>(ops: &mut Vec<OpParams>, params: &OpParams, load_file: F) -> Result<Cid, E>
 where
-    F: FnOnce(&Path) -> Result<Vec<u8>, Error>,
+    F: FnOnce(&Path) -> Result<Vec<u8>, E>,
+    E: From<OpenError> + From<multihash::Error> + From<multicid::Error> + From<PlogError>,
 {
     debug!("load_cid: {:?}", params);
     match params {
diff --git a/crates/bs/src/ops/update.rs b/crates/bs/src/ops/update.rs
index ce1167e..cda0e49 100644
--- a/crates/bs/src/ops/update.rs
+++ b/crates/bs/src/ops/update.rs
@@ -13,7 +13,8 @@ pub use config::Config;
 pub mod op_params;
 pub use op_params::OpParams;
 
-use crate::{error::UpdateError, Error};
+use crate::error::UpdateError;
+use bs_traits::{GetKey, Signer, SyncGetKey, SyncSigner};
 use multicid::{cid, Cid};
 use multicodec::Codec;
 use multihash::mh;
@@ -28,15 +29,23 @@ use std::{fs::read, path::Path};
 use tracing::debug;
 
 /// update a provenance log given the update config
-pub fn update_plog<F1, F2>(
+pub fn update_plog<G, S, E>(
     plog: &mut Log,
     config: Config,
-    get_key: F1,
-    sign_entry: F2,
-) -> Result<Entry, Error>
+    key_manager: &G,
+    signer: &S,
+) -> Result<Entry, E>
 where
-    F1: Fn(&Key, Codec, usize, usize) -> Result<Multikey, Error>,
-    F2: Fn(&Multikey, &[u8]) -> Result<Multisig, Error>,
+    G: GetKey<KeyPath = Key, Codec = Codec, Key = Multikey, Error = E> + SyncGetKey,
+    S: Signer<Key = Multikey, Signature = Multisig, Error = E> + SyncSigner,
+    E: From<UpdateError>
+        + From<PlogError>
+        + From<std::io::Error>
+        + From<multicid::Error>
+        + From<multikey::Error>
+        + From<multihash::Error>
+        + From<crate::Error>
+        + ToString,
 {
     // 0. Set up the list of ops we're going to add
     let mut op_params = Vec::default();
@@ -46,14 +55,14 @@ where
     config
         .entry_ops
         .iter()
-        .try_for_each(|params| -> Result<(), Error> {
+        .try_for_each(|params| -> Result<(), E> {
             match params {
                 p @ OpParams::KeyGen { .. } => {
-                    let _ = load_key(&mut op_params, p, &get_key)?;
+                    let _ = load_key(&mut op_params, p, key_manager)?;
                 }
                 p @ OpParams::CidGen { .. } => {
-                    let _ = load_cid(&mut op_params, p, |path| -> Result<Vec<u8>, Error> {
-                        Ok(read(path)?)
+                    let _ = load_cid(&mut op_params, p, |path| -> Result<Vec<u8>, E> {
+                        read(path).map_err(E::from)
                     })?;
                 }
                 p => op_params.push(p.clone()),
@@ -68,14 +77,14 @@ where
     let unlock_script = {
         let unlock_path = config
             .entry_unlock_script
-            .ok_or::<Error>(UpdateError::NoEntryUnlockScript.into())?;
+            .ok_or::<E>(UpdateError::NoEntryUnlockScript.into())?;
         script::Loader::new(unlock_path).try_build()?
     };
 
     // get the entry signing key
     let entry_mk = config
         .entry_signing_key
-        .ok_or::<Error>(UpdateError::NoSigningKey.into())?;
+        .ok_or::<E>(UpdateError::NoSigningKey.into())?;
 
     // 3. Construct the next entry, starting from the last, calling back to get the entry signed
 
@@ -83,52 +92,51 @@ where
     let mut builder = entry::Builder::from(&last_entry).with_unlock(&unlock_script);
 
     // add in all of the entry Ops
-    op_params
-        .iter()
-        .try_for_each(|params| -> Result<(), Error> {
-            // construct the op
-            let op = match params {
-                OpParams::Noop { key } => op::Builder::new(OpId::Noop)
-                    .with_key_path(key)
-                    .try_build()?,
-                OpParams::Delete { key } => op::Builder::new(OpId::Delete)
-                    .with_key_path(key)
-                    .try_build()?,
-                OpParams::UseCid { key, cid } => {
-                    let v: Vec<u8> = cid.clone().into();
-                    op::Builder::new(OpId::Update)
-                        .with_key_path(key)
-                        .with_data_value(v)
-                        .try_build()?
-                }
-                OpParams::UseKey { key, mk } => {
-                    let v: Vec<u8> = mk.clone().into();
-                    op::Builder::new(OpId::Update)
-                        .with_key_path(key)
-                        .with_data_value(v)
-                        .try_build()?
-                }
-                OpParams::UseStr { key, s } => op::Builder::new(OpId::Update)
+    op_params.iter().try_for_each(|params| -> Result<(), E> {
+        // construct the op
+        let op = match params {
+            OpParams::Noop { key } => op::Builder::new(OpId::Noop)
+                .with_key_path(key)
+                .try_build()?,
+            OpParams::Delete { key } => op::Builder::new(OpId::Delete)
+                .with_key_path(key)
+                .try_build()?,
+            OpParams::UseCid { key, cid } => {
+                let v: Vec<u8> = cid.clone().into();
+                op::Builder::new(OpId::Update)
                     .with_key_path(key)
-                    .with_string_value(s)
-                    .try_build()?,
-                OpParams::UseBin { key, data } => op::Builder::new(OpId::Update)
+                    .with_data_value(v)
+                    .try_build()?
+            }
+            OpParams::UseKey { key, mk } => {
+                let v: Vec<u8> = mk.clone().into();
+                op::Builder::new(OpId::Update)
                     .with_key_path(key)
-                    .with_data_value(data)
-                    .try_build()?,
-                _ => return Err(UpdateError::InvalidOpParams.into()),
-            };
-            // add the op to the builder
-            builder = builder.clone().add_op(&op);
-            Ok(())
-        })?;
+                    .with_data_value(v)
+                    .try_build()?
+            }
+            OpParams::UseStr { key, s } => op::Builder::new(OpId::Update)
+                .with_key_path(key)
+                .with_string_value(s)
+                .try_build()?,
+            OpParams::UseBin { key, data } => op::Builder::new(OpId::Update)
+                .with_key_path(key)
+                .with_data_value(data)
+                .try_build()?,
+            _ => return Err(UpdateError::InvalidOpParams.into()),
+        };
+        // add the op to the builder
+        builder = builder.clone().add_op(&op);
+        Ok(())
+    })?;
 
     // finalize the entry building by signing it
     let entry = builder.try_build(|e| {
         // get the serialzied version of the entry with an empty "proof" field
         let ev: Vec<u8> = e.clone().into();
         // call the call back to have the caller sign the data
-        let ms = sign_entry(&entry_mk, &ev)
+        let ms = signer
+            .try_sign(&entry_mk, &ev)
             .map_err(|e| PlogError::from(EntryError::SignFailed(e.to_string())))?;
         // store the signature as proof
         Ok(ms.into())
@@ -140,13 +148,11 @@ where
     Ok(entry)
 }
 
-fn load_key<F>(
-    ops: &mut Vec<OpParams>,
-    params: &OpParams,
-    mut get_key: F,
-) -> Result<Multikey, Error>
+fn load_key<G, E>(ops: &mut Vec<OpParams>, params: &OpParams, key_manager: &G) -> Result<G::Key, E>
 where
-    F: FnMut(&Key, Codec, usize, usize) -> Result<Multikey, Error>,
+    G: GetKey<Error = E, KeyPath = Key, Codec = Codec> + SyncGetKey,
+    G::Key: Into<Vec<u8>> + Clone + Views,
+    E: From<UpdateError> + From<multikey::Error>,
 {
     debug!("load_key: {:?}", params);
     match params {
@@ -158,7 +164,7 @@ where
             revoke,
         } => {
             // call back to generate the key
-            let mk = get_key(key, *codec, *threshold, *limit)?;
+            let mk = key_manager.get_key(key, codec, *threshold, *limit)?;
 
             // get the public key
             let pk = mk.conv_view()?.to_public_key()?;
@@ -180,9 +186,10 @@ where
     }
 }
 
-fn load_cid<F>(ops: &mut Vec<OpParams>, params: &OpParams, mut load_file: F) -> Result<Cid, Error>
+fn load_cid<F, E>(ops: &mut Vec<OpParams>, params: &OpParams, load_file: F) -> Result<Cid, E>
 where
-    F: FnMut(&Path) -> Result<Vec<u8>, Error>,
+    F: FnOnce(&Path) -> Result<Vec<u8>, E>,
+    E: From<UpdateError> + From<multihash::Error> + From<multicid::Error> + From<PlogError>,
 {
     debug!("load_cid: {:?}", params);
     match params {
diff --git a/crates/comrade-component/.vscode/settings.json b/crates/comrade-component/.vscode/settings.json
new file mode 100644
index 0000000..b945667
--- /dev/null
+++ b/crates/comrade-component/.vscode/settings.json
@@ -0,0 +1,10 @@
+{
+    "rust-analyzer.check.overrideCommand": [
+        "cargo",
+        "component",
+        "check",
+        "--workspace",
+        "--all-targets",
+        "--message-format=json"
+    ],
+}
diff --git a/crates/comrade-component/Cargo.toml b/crates/comrade-component/Cargo.toml
new file mode 100644
index 0000000..580b019
--- /dev/null
+++ b/crates/comrade-component/Cargo.toml
@@ -0,0 +1,23 @@
+[package]
+name = "comrade-component"
+version.workspace = true
+edition.workspace = true
+authors.workspace = true
+description.workspace = true
+readme.workspace = true
+
+[dependencies]
+wit-bindgen-rt = { version = "0.41.0", features = ["bitflags"] }
+comrade-reference.workspace = true
+getrandom = { version = "0.2", features = ["custom"] }
+
+[lints]
+workspace = true
+
+[lib]
+crate-type = ["cdylib"]
+
+[package.metadata.component]
+package = "component:comrade-component"
+
+[package.metadata.component.dependencies]
diff --git a/crates/comrade-component/README.md b/crates/comrade-component/README.md
new file mode 100644
index 0000000..aaea39d
--- /dev/null
+++ b/crates/comrade-component/README.md
@@ -0,0 +1,26 @@
+# Comrade Component
+
+## Overview
+
+This is an example of how the comrade reference implementation can be used to create a wasm component. To give the system maximum flexibility, any user wishing to use their own implementation can build their own component with the same interface and use that instead. 
+
+## Building
+
+To build the component, run the following command:
+
+Prerequisites:
+
+- [cargo-component](https://github.com/bytecodealliance/cargo-component) installed
+- [just](https://just.systems/) installed (opional)
+
+```bash
+just build
+```
+
+This will create a `comrade_component.wasm` file in the `target/wasm32-unknown-unknown/release` directory. This file can be used as a component as a Sctrip runtime in your comrade application, if desired.
+
+Next, use the `comrade::runtime::layer` (or build a wasmtime runtime module) to run the component. The `comrade::runtime::layer` will automatically load the component and make it available to the comrade application.
+
+## Experimental Feature
+
+*Note that this feature is experimental and not used, nor well supported at this time. It is meant as a demonstration for users who wish to pursue this path. If desired by the community, we can add more support for this in the future.
diff --git a/crates/comrade-component/justfile b/crates/comrade-component/justfile
new file mode 100644
index 0000000..2404b83
--- /dev/null
+++ b/crates/comrade-component/justfile
@@ -0,0 +1,9 @@
+# See https://just.systems for more information.
+
+build:
+  # Build the component with cargo-component
+  RUSTFLAGS='--cfg getrandom_backend="custom"' cargo component build --target wasm32-unknown-unknown --release
+
+test: build 
+  cargo test
+
diff --git a/crates/comrade-component/src/bindings.rs b/crates/comrade-component/src/bindings.rs
new file mode 100644
index 0000000..4079dd3
--- /dev/null
+++ b/crates/comrade-component/src/bindings.rs
@@ -0,0 +1,1241 @@
+// Generated by `wit-bindgen` 0.41.0. DO NOT EDIT!
+// Options used:
+//   * runtime_path: "wit_bindgen_rt"
+#[rustfmt::skip]
+#[allow(dead_code, clippy::all)]
+pub mod comrade {
+    pub mod api {
+        #[allow(dead_code, async_fn_in_trait, unused_imports, clippy::all)]
+        pub mod utils {
+            #[used]
+            #[doc(hidden)]
+            static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports;
+            #[allow(unused_unsafe, clippy::all)]
+            /// Logs some output from the guest component.
+            pub fn log(message: &str) -> () {
+                unsafe {
+                    let vec0 = message;
+                    let ptr0 = vec0.as_ptr().cast::<u8>();
+                    let len0 = vec0.len();
+                    #[cfg(target_arch = "wasm32")]
+                    #[link(wasm_import_module = "comrade:api/utils")]
+                    unsafe extern "C" {
+                        #[link_name = "log"]
+                        fn wit_import1(_: *mut u8, _: usize);
+                    }
+                    #[cfg(not(target_arch = "wasm32"))]
+                    unsafe extern "C" fn wit_import1(_: *mut u8, _: usize) {
+                        unreachable!()
+                    }
+                    unsafe { wit_import1(ptr0.cast_mut(), len0) };
+                }
+            }
+            #[allow(unused_unsafe, clippy::all)]
+            /// Get a random byte from the host system
+            pub fn random_byte() -> u8 {
+                unsafe {
+                    #[cfg(target_arch = "wasm32")]
+                    #[link(wasm_import_module = "comrade:api/utils")]
+                    unsafe extern "C" {
+                        #[link_name = "random-byte"]
+                        fn wit_import0() -> i32;
+                    }
+                    #[cfg(not(target_arch = "wasm32"))]
+                    unsafe extern "C" fn wit_import0() -> i32 {
+                        unreachable!()
+                    }
+                    let ret = unsafe { wit_import0() };
+                    ret as u8
+                }
+            }
+        }
+        #[allow(dead_code, async_fn_in_trait, unused_imports, clippy::all)]
+        pub mod pairs {
+            #[used]
+            #[doc(hidden)]
+            static __FORCE_SECTION_REF: fn() = super::super::super::__link_custom_section_describing_imports;
+            use super::super::super::_rt;
+            /// Either current or proposed
+            #[repr(u8)]
+            #[derive(Clone, Copy, Eq, Ord, PartialEq, PartialOrd)]
+            pub enum Either {
+                /// The current kv pairs
+                Current,
+                /// The proposed kv pairs
+                Proposed,
+            }
+            impl ::core::fmt::Debug for Either {
+                fn fmt(
+                    &self,
+                    f: &mut ::core::fmt::Formatter<'_>,
+                ) -> ::core::fmt::Result {
+                    match self {
+                        Either::Current => f.debug_tuple("Either::Current").finish(),
+                        Either::Proposed => f.debug_tuple("Either::Proposed").finish(),
+                    }
+                }
+            }
+            impl Either {
+                #[doc(hidden)]
+                pub unsafe fn _lift(val: u8) -> Either {
+                    if !cfg!(debug_assertions) {
+                        return ::core::mem::transmute(val);
+                    }
+                    match val {
+                        0 => Either::Current,
+                        1 => Either::Proposed,
+                        _ => panic!("invalid enum discriminant"),
+                    }
+                }
+            }
+            /// A binary value and associated hint
+            #[derive(Clone)]
+            pub struct Binary {
+                /// The binary value
+                pub data: _rt::Vec<u8>,
+                /// A hint for the binary value
+                pub hint: _rt::String,
+            }
+            impl ::core::fmt::Debug for Binary {
+                fn fmt(
+                    &self,
+                    f: &mut ::core::fmt::Formatter<'_>,
+                ) -> ::core::fmt::Result {
+                    f.debug_struct("Binary")
+                        .field("data", &self.data)
+                        .field("hint", &self.hint)
+                        .finish()
+                }
+            }
+            /// A string value and associated hint
+            #[derive(Clone)]
+            pub struct Str {
+                /// The string value
+                pub data: _rt::String,
+                /// A hint for the string value
+                pub hint: _rt::String,
+            }
+            impl ::core::fmt::Debug for Str {
+                fn fmt(
+                    &self,
+                    f: &mut ::core::fmt::Formatter<'_>,
+                ) -> ::core::fmt::Result {
+                    f.debug_struct("Str")
+                        .field("data", &self.data)
+                        .field("hint", &self.hint)
+                        .finish()
+                }
+            }
+            /// A variant representing the different types of values that can be stored.
+            #[derive(Clone)]
+            pub enum Value {
+                /// A binary value
+                Bin(Binary),
+                /// A string value
+                Str(Str),
+                /// Success value
+                Success(u32),
+                /// Failure value
+                Failure(_rt::String),
+            }
+            impl ::core::fmt::Debug for Value {
+                fn fmt(
+                    &self,
+                    f: &mut ::core::fmt::Formatter<'_>,
+                ) -> ::core::fmt::Result {
+                    match self {
+                        Value::Bin(e) => f.debug_tuple("Value::Bin").field(e).finish(),
+                        Value::Str(e) => f.debug_tuple("Value::Str").field(e).finish(),
+                        Value::Success(e) => {
+                            f.debug_tuple("Value::Success").field(e).finish()
+                        }
+                        Value::Failure(e) => {
+                            f.debug_tuple("Value::Failure").field(e).finish()
+                        }
+                    }
+                }
+            }
+            #[allow(unused_unsafe, clippy::all)]
+            /// Returns the value of the resource.
+            pub fn put(choice: Either, key: &str, value: &Value) -> Value {
+                unsafe {
+                    #[cfg_attr(target_pointer_width = "64", repr(align(8)))]
+                    #[cfg_attr(target_pointer_width = "32", repr(align(4)))]
+                    struct RetArea(
+                        [::core::mem::MaybeUninit<
+                            u8,
+                        >; 5 * ::core::mem::size_of::<*const u8>()],
+                    );
+                    let mut ret_area = RetArea(
+                        [::core::mem::MaybeUninit::uninit(); 5
+                            * ::core::mem::size_of::<*const u8>()],
+                    );
+                    let vec0 = key;
+                    let ptr0 = vec0.as_ptr().cast::<u8>();
+                    let len0 = vec0.len();
+                    let (result8_0, result8_1, result8_2, result8_3, result8_4) = match value {
+                        Value::Bin(e) => {
+                            let Binary { data: data1, hint: hint1 } = e;
+                            let vec2 = data1;
+                            let ptr2 = vec2.as_ptr().cast::<u8>();
+                            let len2 = vec2.len();
+                            let vec3 = hint1;
+                            let ptr3 = vec3.as_ptr().cast::<u8>();
+                            let len3 = vec3.len();
+                            (0i32, ptr2.cast_mut(), len2, ptr3.cast_mut(), len3)
+                        }
+                        Value::Str(e) => {
+                            let Str { data: data4, hint: hint4 } = e;
+                            let vec5 = data4;
+                            let ptr5 = vec5.as_ptr().cast::<u8>();
+                            let len5 = vec5.len();
+                            let vec6 = hint4;
+                            let ptr6 = vec6.as_ptr().cast::<u8>();
+                            let len6 = vec6.len();
+                            (1i32, ptr5.cast_mut(), len5, ptr6.cast_mut(), len6)
+                        }
+                        Value::Success(e) => {
+                            (
+                                2i32,
+                                _rt::as_i32(e) as *mut u8,
+                                0usize,
+                                ::core::ptr::null_mut(),
+                                0usize,
+                            )
+                        }
+                        Value::Failure(e) => {
+                            let vec7 = e;
+                            let ptr7 = vec7.as_ptr().cast::<u8>();
+                            let len7 = vec7.len();
+                            (
+                                3i32,
+                                ptr7.cast_mut(),
+                                len7,
+                                ::core::ptr::null_mut(),
+                                0usize,
+                            )
+                        }
+                    };
+                    let ptr9 = ret_area.0.as_mut_ptr().cast::<u8>();
+                    #[cfg(target_arch = "wasm32")]
+                    #[link(wasm_import_module = "comrade:api/pairs")]
+                    unsafe extern "C" {
+                        #[link_name = "put"]
+                        fn wit_import10(
+                            _: i32,
+                            _: *mut u8,
+                            _: usize,
+                            _: i32,
+                            _: *mut u8,
+                            _: usize,
+                            _: *mut u8,
+                            _: usize,
+                            _: *mut u8,
+                        );
+                    }
+                    #[cfg(not(target_arch = "wasm32"))]
+                    unsafe extern "C" fn wit_import10(
+                        _: i32,
+                        _: *mut u8,
+                        _: usize,
+                        _: i32,
+                        _: *mut u8,
+                        _: usize,
+                        _: *mut u8,
+                        _: usize,
+                        _: *mut u8,
+                    ) {
+                        unreachable!()
+                    }
+                    unsafe {
+                        wit_import10(
+                            choice.clone() as i32,
+                            ptr0.cast_mut(),
+                            len0,
+                            result8_0,
+                            result8_1,
+                            result8_2,
+                            result8_3,
+                            result8_4,
+                            ptr9,
+                        )
+                    };
+                    let l11 = i32::from(*ptr9.add(0).cast::<u8>());
+                    let v28 = match l11 {
+                        0 => {
+                            let e28 = {
+                                let l12 = *ptr9
+                                    .add(::core::mem::size_of::<*const u8>())
+                                    .cast::<*mut u8>();
+                                let l13 = *ptr9
+                                    .add(2 * ::core::mem::size_of::<*const u8>())
+                                    .cast::<usize>();
+                                let len14 = l13;
+                                let l15 = *ptr9
+                                    .add(3 * ::core::mem::size_of::<*const u8>())
+                                    .cast::<*mut u8>();
+                                let l16 = *ptr9
+                                    .add(4 * ::core::mem::size_of::<*const u8>())
+                                    .cast::<usize>();
+                                let len17 = l16;
+                                let bytes17 = _rt::Vec::from_raw_parts(
+                                    l15.cast(),
+                                    len17,
+                                    len17,
+                                );
+                                Binary {
+                                    data: _rt::Vec::from_raw_parts(l12.cast(), len14, len14),
+                                    hint: _rt::string_lift(bytes17),
+                                }
+                            };
+                            Value::Bin(e28)
+                        }
+                        1 => {
+                            let e28 = {
+                                let l18 = *ptr9
+                                    .add(::core::mem::size_of::<*const u8>())
+                                    .cast::<*mut u8>();
+                                let l19 = *ptr9
+                                    .add(2 * ::core::mem::size_of::<*const u8>())
+                                    .cast::<usize>();
+                                let len20 = l19;
+                                let bytes20 = _rt::Vec::from_raw_parts(
+                                    l18.cast(),
+                                    len20,
+                                    len20,
+                                );
+                                let l21 = *ptr9
+                                    .add(3 * ::core::mem::size_of::<*const u8>())
+                                    .cast::<*mut u8>();
+                                let l22 = *ptr9
+                                    .add(4 * ::core::mem::size_of::<*const u8>())
+                                    .cast::<usize>();
+                                let len23 = l22;
+                                let bytes23 = _rt::Vec::from_raw_parts(
+                                    l21.cast(),
+                                    len23,
+                                    len23,
+                                );
+                                Str {
+                                    data: _rt::string_lift(bytes20),
+                                    hint: _rt::string_lift(bytes23),
+                                }
+                            };
+                            Value::Str(e28)
+                        }
+                        2 => {
+                            let e28 = {
+                                let l24 = *ptr9
+                                    .add(::core::mem::size_of::<*const u8>())
+                                    .cast::<i32>();
+                                l24 as u32
+                            };
+                            Value::Success(e28)
+                        }
+                        n => {
+                            debug_assert_eq!(n, 3, "invalid enum discriminant");
+                            let e28 = {
+                                let l25 = *ptr9
+                                    .add(::core::mem::size_of::<*const u8>())
+                                    .cast::<*mut u8>();
+                                let l26 = *ptr9
+                                    .add(2 * ::core::mem::size_of::<*const u8>())
+                                    .cast::<usize>();
+                                let len27 = l26;
+                                let bytes27 = _rt::Vec::from_raw_parts(
+                                    l25.cast(),
+                                    len27,
+                                    len27,
+                                );
+                                _rt::string_lift(bytes27)
+                            };
+                            Value::Failure(e28)
+                        }
+                    };
+                    let result29 = v28;
+                    result29
+                }
+            }
+            #[allow(unused_unsafe, clippy::all)]
+            /// Returns the value of the resource.
+            /// Get a value from the given key, if it exists.
+            /// Returns some value or None.
+            pub fn get(choice: Either, key: &str) -> Option<Value> {
+                unsafe {
+                    #[cfg_attr(target_pointer_width = "64", repr(align(8)))]
+                    #[cfg_attr(target_pointer_width = "32", repr(align(4)))]
+                    struct RetArea(
+                        [::core::mem::MaybeUninit<
+                            u8,
+                        >; 6 * ::core::mem::size_of::<*const u8>()],
+                    );
+                    let mut ret_area = RetArea(
+                        [::core::mem::MaybeUninit::uninit(); 6
+                            * ::core::mem::size_of::<*const u8>()],
+                    );
+                    let vec0 = key;
+                    let ptr0 = vec0.as_ptr().cast::<u8>();
+                    let len0 = vec0.len();
+                    let ptr1 = ret_area.0.as_mut_ptr().cast::<u8>();
+                    #[cfg(target_arch = "wasm32")]
+                    #[link(wasm_import_module = "comrade:api/pairs")]
+                    unsafe extern "C" {
+                        #[link_name = "get"]
+                        fn wit_import2(_: i32, _: *mut u8, _: usize, _: *mut u8);
+                    }
+                    #[cfg(not(target_arch = "wasm32"))]
+                    unsafe extern "C" fn wit_import2(
+                        _: i32,
+                        _: *mut u8,
+                        _: usize,
+                        _: *mut u8,
+                    ) {
+                        unreachable!()
+                    }
+                    unsafe {
+                        wit_import2(choice.clone() as i32, ptr0.cast_mut(), len0, ptr1)
+                    };
+                    let l3 = i32::from(*ptr1.add(0).cast::<u8>());
+                    let result22 = match l3 {
+                        0 => None,
+                        1 => {
+                            let e = {
+                                let l4 = i32::from(
+                                    *ptr1.add(::core::mem::size_of::<*const u8>()).cast::<u8>(),
+                                );
+                                let v21 = match l4 {
+                                    0 => {
+                                        let e21 = {
+                                            let l5 = *ptr1
+                                                .add(2 * ::core::mem::size_of::<*const u8>())
+                                                .cast::<*mut u8>();
+                                            let l6 = *ptr1
+                                                .add(3 * ::core::mem::size_of::<*const u8>())
+                                                .cast::<usize>();
+                                            let len7 = l6;
+                                            let l8 = *ptr1
+                                                .add(4 * ::core::mem::size_of::<*const u8>())
+                                                .cast::<*mut u8>();
+                                            let l9 = *ptr1
+                                                .add(5 * ::core::mem::size_of::<*const u8>())
+                                                .cast::<usize>();
+                                            let len10 = l9;
+                                            let bytes10 = _rt::Vec::from_raw_parts(
+                                                l8.cast(),
+                                                len10,
+                                                len10,
+                                            );
+                                            Binary {
+                                                data: _rt::Vec::from_raw_parts(l5.cast(), len7, len7),
+                                                hint: _rt::string_lift(bytes10),
+                                            }
+                                        };
+                                        Value::Bin(e21)
+                                    }
+                                    1 => {
+                                        let e21 = {
+                                            let l11 = *ptr1
+                                                .add(2 * ::core::mem::size_of::<*const u8>())
+                                                .cast::<*mut u8>();
+                                            let l12 = *ptr1
+                                                .add(3 * ::core::mem::size_of::<*const u8>())
+                                                .cast::<usize>();
+                                            let len13 = l12;
+                                            let bytes13 = _rt::Vec::from_raw_parts(
+                                                l11.cast(),
+                                                len13,
+                                                len13,
+                                            );
+                                            let l14 = *ptr1
+                                                .add(4 * ::core::mem::size_of::<*const u8>())
+                                                .cast::<*mut u8>();
+                                            let l15 = *ptr1
+                                                .add(5 * ::core::mem::size_of::<*const u8>())
+                                                .cast::<usize>();
+                                            let len16 = l15;
+                                            let bytes16 = _rt::Vec::from_raw_parts(
+                                                l14.cast(),
+                                                len16,
+                                                len16,
+                                            );
+                                            Str {
+                                                data: _rt::string_lift(bytes13),
+                                                hint: _rt::string_lift(bytes16),
+                                            }
+                                        };
+                                        Value::Str(e21)
+                                    }
+                                    2 => {
+                                        let e21 = {
+                                            let l17 = *ptr1
+                                                .add(2 * ::core::mem::size_of::<*const u8>())
+                                                .cast::<i32>();
+                                            l17 as u32
+                                        };
+                                        Value::Success(e21)
+                                    }
+                                    n => {
+                                        debug_assert_eq!(n, 3, "invalid enum discriminant");
+                                        let e21 = {
+                                            let l18 = *ptr1
+                                                .add(2 * ::core::mem::size_of::<*const u8>())
+                                                .cast::<*mut u8>();
+                                            let l19 = *ptr1
+                                                .add(3 * ::core::mem::size_of::<*const u8>())
+                                                .cast::<usize>();
+                                            let len20 = l19;
+                                            let bytes20 = _rt::Vec::from_raw_parts(
+                                                l18.cast(),
+                                                len20,
+                                                len20,
+                                            );
+                                            _rt::string_lift(bytes20)
+                                        };
+                                        Value::Failure(e21)
+                                    }
+                                };
+                                v21
+                            };
+                            Some(e)
+                        }
+                        _ => _rt::invalid_enum_discriminant(),
+                    };
+                    result22
+                }
+            }
+        }
+    }
+}
+#[rustfmt::skip]
+#[allow(dead_code, clippy::all)]
+pub mod exports {
+    pub mod comrade {
+        pub mod api {
+            #[allow(dead_code, async_fn_in_trait, unused_imports, clippy::all)]
+            pub mod api {
+                #[used]
+                #[doc(hidden)]
+                static __FORCE_SECTION_REF: fn() = super::super::super::super::__link_custom_section_describing_imports;
+                use super::super::super::super::_rt;
+                pub type Value = super::super::super::super::comrade::api::pairs::Value;
+                /// The main API resource
+                #[derive(Debug)]
+                #[repr(transparent)]
+                pub struct Api {
+                    handle: _rt::Resource<Api>,
+                }
+                type _ApiRep<T> = Option<T>;
+                impl Api {
+                    /// Creates a new resource from the specified representation.
+                    ///
+                    /// This function will create a new resource handle by moving `val` onto
+                    /// the heap and then passing that heap pointer to the component model to
+                    /// create a handle. The owned handle is then returned as `Api`.
+                    pub fn new<T: GuestApi>(val: T) -> Self {
+                        Self::type_guard::<T>();
+                        let val: _ApiRep<T> = Some(val);
+                        let ptr: *mut _ApiRep<T> = _rt::Box::into_raw(
+                            _rt::Box::new(val),
+                        );
+                        unsafe { Self::from_handle(T::_resource_new(ptr.cast())) }
+                    }
+                    /// Gets access to the underlying `T` which represents this resource.
+                    pub fn get<T: GuestApi>(&self) -> &T {
+                        let ptr = unsafe { &*self.as_ptr::<T>() };
+                        ptr.as_ref().unwrap()
+                    }
+                    /// Gets mutable access to the underlying `T` which represents this
+                    /// resource.
+                    pub fn get_mut<T: GuestApi>(&mut self) -> &mut T {
+                        let ptr = unsafe { &mut *self.as_ptr::<T>() };
+                        ptr.as_mut().unwrap()
+                    }
+                    /// Consumes this resource and returns the underlying `T`.
+                    pub fn into_inner<T: GuestApi>(self) -> T {
+                        let ptr = unsafe { &mut *self.as_ptr::<T>() };
+                        ptr.take().unwrap()
+                    }
+                    #[doc(hidden)]
+                    pub unsafe fn from_handle(handle: u32) -> Self {
+                        Self {
+                            handle: unsafe { _rt::Resource::from_handle(handle) },
+                        }
+                    }
+                    #[doc(hidden)]
+                    pub fn take_handle(&self) -> u32 {
+                        _rt::Resource::take_handle(&self.handle)
+                    }
+                    #[doc(hidden)]
+                    pub fn handle(&self) -> u32 {
+                        _rt::Resource::handle(&self.handle)
+                    }
+                    #[doc(hidden)]
+                    fn type_guard<T: 'static>() {
+                        use core::any::TypeId;
+                        static mut LAST_TYPE: Option<TypeId> = None;
+                        unsafe {
+                            assert!(! cfg!(target_feature = "atomics"));
+                            let id = TypeId::of::<T>();
+                            match LAST_TYPE {
+                                Some(ty) => {
+                                    assert!(
+                                        ty == id, "cannot use two types with this resource type"
+                                    )
+                                }
+                                None => LAST_TYPE = Some(id),
+                            }
+                        }
+                    }
+                    #[doc(hidden)]
+                    pub unsafe fn dtor<T: 'static>(handle: *mut u8) {
+                        Self::type_guard::<T>();
+                        let _ = unsafe { _rt::Box::from_raw(handle as *mut _ApiRep<T>) };
+                    }
+                    fn as_ptr<T: GuestApi>(&self) -> *mut _ApiRep<T> {
+                        Api::type_guard::<T>();
+                        T::_resource_rep(self.handle()).cast()
+                    }
+                }
+                /// A borrowed version of [`Api`] which represents a borrowed value
+                /// with the lifetime `'a`.
+                #[derive(Debug)]
+                #[repr(transparent)]
+                pub struct ApiBorrow<'a> {
+                    rep: *mut u8,
+                    _marker: core::marker::PhantomData<&'a Api>,
+                }
+                impl<'a> ApiBorrow<'a> {
+                    #[doc(hidden)]
+                    pub unsafe fn lift(rep: usize) -> Self {
+                        Self {
+                            rep: rep as *mut u8,
+                            _marker: core::marker::PhantomData,
+                        }
+                    }
+                    /// Gets access to the underlying `T` in this resource.
+                    pub fn get<T: GuestApi>(&self) -> &T {
+                        let ptr = unsafe { &mut *self.as_ptr::<T>() };
+                        ptr.as_ref().unwrap()
+                    }
+                    fn as_ptr<T: 'static>(&self) -> *mut _ApiRep<T> {
+                        Api::type_guard::<T>();
+                        self.rep.cast()
+                    }
+                }
+                unsafe impl _rt::WasmResource for Api {
+                    #[inline]
+                    unsafe fn drop(_handle: u32) {
+                        #[cfg(not(target_arch = "wasm32"))]
+                        unreachable!();
+                        #[cfg(target_arch = "wasm32")]
+                        {
+                            #[link(wasm_import_module = "[export]comrade:api/api")]
+                            unsafe extern "C" {
+                                #[link_name = "[resource-drop]api"]
+                                fn drop(_: u32);
+                            }
+                            unsafe { drop(_handle) };
+                        }
+                    }
+                }
+                #[doc(hidden)]
+                #[allow(non_snake_case)]
+                pub unsafe fn _export_constructor_api_cabi<T: GuestApi>() -> i32 {
+                    #[cfg(target_arch = "wasm32")] _rt::run_ctors_once();
+                    let result0 = Api::new(T::new());
+                    (result0).take_handle() as i32
+                }
+                #[doc(hidden)]
+                #[allow(non_snake_case)]
+                pub unsafe fn _export_method_api_try_unlock_cabi<T: GuestApi>(
+                    arg0: *mut u8,
+                    arg1: *mut u8,
+                    arg2: usize,
+                ) -> *mut u8 {
+                    #[cfg(target_arch = "wasm32")] _rt::run_ctors_once();
+                    let len0 = arg2;
+                    let bytes0 = _rt::Vec::from_raw_parts(arg1.cast(), len0, len0);
+                    let result1 = T::try_unlock(
+                        unsafe { ApiBorrow::lift(arg0 as u32 as usize) }.get(),
+                        _rt::string_lift(bytes0),
+                    );
+                    let ptr2 = (&raw mut _RET_AREA.0).cast::<u8>();
+                    match result1 {
+                        Ok(_) => {
+                            *ptr2.add(0).cast::<u8>() = (0i32) as u8;
+                        }
+                        Err(e) => {
+                            *ptr2.add(0).cast::<u8>() = (1i32) as u8;
+                            let vec3 = (e.into_bytes()).into_boxed_slice();
+                            let ptr3 = vec3.as_ptr().cast::<u8>();
+                            let len3 = vec3.len();
+                            ::core::mem::forget(vec3);
+                            *ptr2
+                                .add(2 * ::core::mem::size_of::<*const u8>())
+                                .cast::<usize>() = len3;
+                            *ptr2
+                                .add(::core::mem::size_of::<*const u8>())
+                                .cast::<*mut u8>() = ptr3.cast_mut();
+                        }
+                    };
+                    ptr2
+                }
+                #[doc(hidden)]
+                #[allow(non_snake_case)]
+                pub unsafe fn __post_return_method_api_try_unlock<T: GuestApi>(
+                    arg0: *mut u8,
+                ) {
+                    let l0 = i32::from(*arg0.add(0).cast::<u8>());
+                    match l0 {
+                        0 => {}
+                        _ => {
+                            let l1 = *arg0
+                                .add(::core::mem::size_of::<*const u8>())
+                                .cast::<*mut u8>();
+                            let l2 = *arg0
+                                .add(2 * ::core::mem::size_of::<*const u8>())
+                                .cast::<usize>();
+                            _rt::cabi_dealloc(l1, l2, 1);
+                        }
+                    }
+                }
+                #[doc(hidden)]
+                #[allow(non_snake_case)]
+                pub unsafe fn _export_method_api_try_lock_cabi<T: GuestApi>(
+                    arg0: *mut u8,
+                    arg1: *mut u8,
+                    arg2: usize,
+                ) -> *mut u8 {
+                    #[cfg(target_arch = "wasm32")] _rt::run_ctors_once();
+                    let len0 = arg2;
+                    let bytes0 = _rt::Vec::from_raw_parts(arg1.cast(), len0, len0);
+                    let result1 = T::try_lock(
+                        unsafe { ApiBorrow::lift(arg0 as u32 as usize) }.get(),
+                        _rt::string_lift(bytes0),
+                    );
+                    let ptr2 = (&raw mut _RET_AREA.0).cast::<u8>();
+                    match result1 {
+                        Ok(e) => {
+                            *ptr2.add(0).cast::<u8>() = (0i32) as u8;
+                            match e {
+                                Some(e) => {
+                                    *ptr2
+                                        .add(::core::mem::size_of::<*const u8>())
+                                        .cast::<u8>() = (1i32) as u8;
+                                    use super::super::super::super::comrade::api::pairs::Value as V10;
+                                    match e {
+                                        V10::Bin(e) => {
+                                            *ptr2
+                                                .add(2 * ::core::mem::size_of::<*const u8>())
+                                                .cast::<u8>() = (0i32) as u8;
+                                            let super::super::super::super::comrade::api::pairs::Binary {
+                                                data: data3,
+                                                hint: hint3,
+                                            } = e;
+                                            let vec4 = (data3).into_boxed_slice();
+                                            let ptr4 = vec4.as_ptr().cast::<u8>();
+                                            let len4 = vec4.len();
+                                            ::core::mem::forget(vec4);
+                                            *ptr2
+                                                .add(4 * ::core::mem::size_of::<*const u8>())
+                                                .cast::<usize>() = len4;
+                                            *ptr2
+                                                .add(3 * ::core::mem::size_of::<*const u8>())
+                                                .cast::<*mut u8>() = ptr4.cast_mut();
+                                            let vec5 = (hint3.into_bytes()).into_boxed_slice();
+                                            let ptr5 = vec5.as_ptr().cast::<u8>();
+                                            let len5 = vec5.len();
+                                            ::core::mem::forget(vec5);
+                                            *ptr2
+                                                .add(6 * ::core::mem::size_of::<*const u8>())
+                                                .cast::<usize>() = len5;
+                                            *ptr2
+                                                .add(5 * ::core::mem::size_of::<*const u8>())
+                                                .cast::<*mut u8>() = ptr5.cast_mut();
+                                        }
+                                        V10::Str(e) => {
+                                            *ptr2
+                                                .add(2 * ::core::mem::size_of::<*const u8>())
+                                                .cast::<u8>() = (1i32) as u8;
+                                            let super::super::super::super::comrade::api::pairs::Str {
+                                                data: data6,
+                                                hint: hint6,
+                                            } = e;
+                                            let vec7 = (data6.into_bytes()).into_boxed_slice();
+                                            let ptr7 = vec7.as_ptr().cast::<u8>();
+                                            let len7 = vec7.len();
+                                            ::core::mem::forget(vec7);
+                                            *ptr2
+                                                .add(4 * ::core::mem::size_of::<*const u8>())
+                                                .cast::<usize>() = len7;
+                                            *ptr2
+                                                .add(3 * ::core::mem::size_of::<*const u8>())
+                                                .cast::<*mut u8>() = ptr7.cast_mut();
+                                            let vec8 = (hint6.into_bytes()).into_boxed_slice();
+                                            let ptr8 = vec8.as_ptr().cast::<u8>();
+                                            let len8 = vec8.len();
+                                            ::core::mem::forget(vec8);
+                                            *ptr2
+                                                .add(6 * ::core::mem::size_of::<*const u8>())
+                                                .cast::<usize>() = len8;
+                                            *ptr2
+                                                .add(5 * ::core::mem::size_of::<*const u8>())
+                                                .cast::<*mut u8>() = ptr8.cast_mut();
+                                        }
+                                        V10::Success(e) => {
+                                            *ptr2
+                                                .add(2 * ::core::mem::size_of::<*const u8>())
+                                                .cast::<u8>() = (2i32) as u8;
+                                            *ptr2
+                                                .add(3 * ::core::mem::size_of::<*const u8>())
+                                                .cast::<i32>() = _rt::as_i32(e);
+                                        }
+                                        V10::Failure(e) => {
+                                            *ptr2
+                                                .add(2 * ::core::mem::size_of::<*const u8>())
+                                                .cast::<u8>() = (3i32) as u8;
+                                            let vec9 = (e.into_bytes()).into_boxed_slice();
+                                            let ptr9 = vec9.as_ptr().cast::<u8>();
+                                            let len9 = vec9.len();
+                                            ::core::mem::forget(vec9);
+                                            *ptr2
+                                                .add(4 * ::core::mem::size_of::<*const u8>())
+                                                .cast::<usize>() = len9;
+                                            *ptr2
+                                                .add(3 * ::core::mem::size_of::<*const u8>())
+                                                .cast::<*mut u8>() = ptr9.cast_mut();
+                                        }
+                                    }
+                                }
+                                None => {
+                                    *ptr2
+                                        .add(::core::mem::size_of::<*const u8>())
+                                        .cast::<u8>() = (0i32) as u8;
+                                }
+                            };
+                        }
+                        Err(e) => {
+                            *ptr2.add(0).cast::<u8>() = (1i32) as u8;
+                            let vec11 = (e.into_bytes()).into_boxed_slice();
+                            let ptr11 = vec11.as_ptr().cast::<u8>();
+                            let len11 = vec11.len();
+                            ::core::mem::forget(vec11);
+                            *ptr2
+                                .add(2 * ::core::mem::size_of::<*const u8>())
+                                .cast::<usize>() = len11;
+                            *ptr2
+                                .add(::core::mem::size_of::<*const u8>())
+                                .cast::<*mut u8>() = ptr11.cast_mut();
+                        }
+                    };
+                    ptr2
+                }
+                #[doc(hidden)]
+                #[allow(non_snake_case)]
+                pub unsafe fn __post_return_method_api_try_lock<T: GuestApi>(
+                    arg0: *mut u8,
+                ) {
+                    let l0 = i32::from(*arg0.add(0).cast::<u8>());
+                    match l0 {
+                        0 => {
+                            let l1 = i32::from(
+                                *arg0.add(::core::mem::size_of::<*const u8>()).cast::<u8>(),
+                            );
+                            match l1 {
+                                0 => {}
+                                _ => {
+                                    let l2 = i32::from(
+                                        *arg0
+                                            .add(2 * ::core::mem::size_of::<*const u8>())
+                                            .cast::<u8>(),
+                                    );
+                                    match l2 {
+                                        0 => {
+                                            let l3 = *arg0
+                                                .add(3 * ::core::mem::size_of::<*const u8>())
+                                                .cast::<*mut u8>();
+                                            let l4 = *arg0
+                                                .add(4 * ::core::mem::size_of::<*const u8>())
+                                                .cast::<usize>();
+                                            let base5 = l3;
+                                            let len5 = l4;
+                                            _rt::cabi_dealloc(base5, len5 * 1, 1);
+                                            let l6 = *arg0
+                                                .add(5 * ::core::mem::size_of::<*const u8>())
+                                                .cast::<*mut u8>();
+                                            let l7 = *arg0
+                                                .add(6 * ::core::mem::size_of::<*const u8>())
+                                                .cast::<usize>();
+                                            _rt::cabi_dealloc(l6, l7, 1);
+                                        }
+                                        1 => {
+                                            let l8 = *arg0
+                                                .add(3 * ::core::mem::size_of::<*const u8>())
+                                                .cast::<*mut u8>();
+                                            let l9 = *arg0
+                                                .add(4 * ::core::mem::size_of::<*const u8>())
+                                                .cast::<usize>();
+                                            _rt::cabi_dealloc(l8, l9, 1);
+                                            let l10 = *arg0
+                                                .add(5 * ::core::mem::size_of::<*const u8>())
+                                                .cast::<*mut u8>();
+                                            let l11 = *arg0
+                                                .add(6 * ::core::mem::size_of::<*const u8>())
+                                                .cast::<usize>();
+                                            _rt::cabi_dealloc(l10, l11, 1);
+                                        }
+                                        2 => {}
+                                        _ => {
+                                            let l12 = *arg0
+                                                .add(3 * ::core::mem::size_of::<*const u8>())
+                                                .cast::<*mut u8>();
+                                            let l13 = *arg0
+                                                .add(4 * ::core::mem::size_of::<*const u8>())
+                                                .cast::<usize>();
+                                            _rt::cabi_dealloc(l12, l13, 1);
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        _ => {
+                            let l14 = *arg0
+                                .add(::core::mem::size_of::<*const u8>())
+                                .cast::<*mut u8>();
+                            let l15 = *arg0
+                                .add(2 * ::core::mem::size_of::<*const u8>())
+                                .cast::<usize>();
+                            _rt::cabi_dealloc(l14, l15, 1);
+                        }
+                    }
+                }
+                pub trait Guest {
+                    type Api: GuestApi;
+                }
+                pub trait GuestApi: 'static {
+                    #[doc(hidden)]
+                    unsafe fn _resource_new(val: *mut u8) -> u32
+                    where
+                        Self: Sized,
+                    {
+                        #[cfg(not(target_arch = "wasm32"))]
+                        {
+                            let _ = val;
+                            unreachable!();
+                        }
+                        #[cfg(target_arch = "wasm32")]
+                        {
+                            #[link(wasm_import_module = "[export]comrade:api/api")]
+                            unsafe extern "C" {
+                                #[link_name = "[resource-new]api"]
+                                fn new(_: *mut u8) -> u32;
+                            }
+                            unsafe { new(val) }
+                        }
+                    }
+                    #[doc(hidden)]
+                    fn _resource_rep(handle: u32) -> *mut u8
+                    where
+                        Self: Sized,
+                    {
+                        #[cfg(not(target_arch = "wasm32"))]
+                        {
+                            let _ = handle;
+                            unreachable!();
+                        }
+                        #[cfg(target_arch = "wasm32")]
+                        {
+                            #[link(wasm_import_module = "[export]comrade:api/api")]
+                            unsafe extern "C" {
+                                #[link_name = "[resource-rep]api"]
+                                fn rep(_: u32) -> *mut u8;
+                            }
+                            unsafe { rep(handle) }
+                        }
+                    }
+                    /// The main API function
+                    fn new() -> Self;
+                    /// Set the unlock script Fails if the script is not valid.
+                    fn try_unlock(&self, script: _rt::String) -> Result<(), _rt::String>;
+                    /// Tries a lock script
+                    fn try_lock(
+                        &self,
+                        lock: _rt::String,
+                    ) -> Result<Option<Value>, _rt::String>;
+                }
+                #[doc(hidden)]
+                macro_rules! __export_comrade_api_api_cabi {
+                    ($ty:ident with_types_in $($path_to_types:tt)*) => {
+                        const _ : () = { #[unsafe (export_name =
+                        "comrade:api/api#[constructor]api")] unsafe extern "C" fn
+                        export_constructor_api() -> i32 { unsafe { $($path_to_types)*::
+                        _export_constructor_api_cabi::<<$ty as $($path_to_types)*:: Guest
+                        >::Api > () } } #[unsafe (export_name =
+                        "comrade:api/api#[method]api.try-unlock")] unsafe extern "C" fn
+                        export_method_api_try_unlock(arg0 : * mut u8, arg1 : * mut u8,
+                        arg2 : usize,) -> * mut u8 { unsafe { $($path_to_types)*::
+                        _export_method_api_try_unlock_cabi::<<$ty as $($path_to_types)*::
+                        Guest >::Api > (arg0, arg1, arg2) } } #[unsafe (export_name =
+                        "cabi_post_comrade:api/api#[method]api.try-unlock")] unsafe
+                        extern "C" fn _post_return_method_api_try_unlock(arg0 : * mut
+                        u8,) { unsafe { $($path_to_types)*::
+                        __post_return_method_api_try_unlock::<<$ty as
+                        $($path_to_types)*:: Guest >::Api > (arg0) } } #[unsafe
+                        (export_name = "comrade:api/api#[method]api.try-lock")] unsafe
+                        extern "C" fn export_method_api_try_lock(arg0 : * mut u8, arg1 :
+                        * mut u8, arg2 : usize,) -> * mut u8 { unsafe {
+                        $($path_to_types)*:: _export_method_api_try_lock_cabi::<<$ty as
+                        $($path_to_types)*:: Guest >::Api > (arg0, arg1, arg2) } }
+                        #[unsafe (export_name =
+                        "cabi_post_comrade:api/api#[method]api.try-lock")] unsafe extern
+                        "C" fn _post_return_method_api_try_lock(arg0 : * mut u8,) {
+                        unsafe { $($path_to_types)*::
+                        __post_return_method_api_try_lock::<<$ty as $($path_to_types)*::
+                        Guest >::Api > (arg0) } } const _ : () = { #[doc(hidden)]
+                        #[unsafe (export_name = "comrade:api/api#[dtor]api")]
+                        #[allow(non_snake_case)] unsafe extern "C" fn dtor(rep : * mut
+                        u8) { unsafe { $($path_to_types)*:: Api::dtor::< <$ty as
+                        $($path_to_types)*:: Guest >::Api > (rep) } } }; };
+                    };
+                }
+                #[doc(hidden)]
+                pub(crate) use __export_comrade_api_api_cabi;
+                #[cfg_attr(target_pointer_width = "64", repr(align(8)))]
+                #[cfg_attr(target_pointer_width = "32", repr(align(4)))]
+                struct _RetArea(
+                    [::core::mem::MaybeUninit<
+                        u8,
+                    >; 7 * ::core::mem::size_of::<*const u8>()],
+                );
+                static mut _RET_AREA: _RetArea = _RetArea(
+                    [::core::mem::MaybeUninit::uninit(); 7
+                        * ::core::mem::size_of::<*const u8>()],
+                );
+            }
+        }
+    }
+}
+#[rustfmt::skip]
+mod _rt {
+    #![allow(dead_code, clippy::all)]
+    pub use alloc_crate::vec::Vec;
+    pub use alloc_crate::string::String;
+    pub fn as_i32<T: AsI32>(t: T) -> i32 {
+        t.as_i32()
+    }
+    pub trait AsI32 {
+        fn as_i32(self) -> i32;
+    }
+    impl<'a, T: Copy + AsI32> AsI32 for &'a T {
+        fn as_i32(self) -> i32 {
+            (*self).as_i32()
+        }
+    }
+    impl AsI32 for i32 {
+        #[inline]
+        fn as_i32(self) -> i32 {
+            self as i32
+        }
+    }
+    impl AsI32 for u32 {
+        #[inline]
+        fn as_i32(self) -> i32 {
+            self as i32
+        }
+    }
+    impl AsI32 for i16 {
+        #[inline]
+        fn as_i32(self) -> i32 {
+            self as i32
+        }
+    }
+    impl AsI32 for u16 {
+        #[inline]
+        fn as_i32(self) -> i32 {
+            self as i32
+        }
+    }
+    impl AsI32 for i8 {
+        #[inline]
+        fn as_i32(self) -> i32 {
+            self as i32
+        }
+    }
+    impl AsI32 for u8 {
+        #[inline]
+        fn as_i32(self) -> i32 {
+            self as i32
+        }
+    }
+    impl AsI32 for char {
+        #[inline]
+        fn as_i32(self) -> i32 {
+            self as i32
+        }
+    }
+    impl AsI32 for usize {
+        #[inline]
+        fn as_i32(self) -> i32 {
+            self as i32
+        }
+    }
+    pub unsafe fn string_lift(bytes: Vec<u8>) -> String {
+        if cfg!(debug_assertions) {
+            String::from_utf8(bytes).unwrap()
+        } else {
+            String::from_utf8_unchecked(bytes)
+        }
+    }
+    pub unsafe fn invalid_enum_discriminant<T>() -> T {
+        if cfg!(debug_assertions) {
+            panic!("invalid enum discriminant")
+        } else {
+            unsafe { core::hint::unreachable_unchecked() }
+        }
+    }
+    use core::fmt;
+    use core::marker;
+    use core::sync::atomic::{AtomicU32, Ordering::Relaxed};
+    /// A type which represents a component model resource, either imported or
+    /// exported into this component.
+    ///
+    /// This is a low-level wrapper which handles the lifetime of the resource
+    /// (namely this has a destructor). The `T` provided defines the component model
+    /// intrinsics that this wrapper uses.
+    ///
+    /// One of the chief purposes of this type is to provide `Deref` implementations
+    /// to access the underlying data when it is owned.
+    ///
+    /// This type is primarily used in generated code for exported and imported
+    /// resources.
+    #[repr(transparent)]
+    pub struct Resource<T: WasmResource> {
+        handle: AtomicU32,
+        _marker: marker::PhantomData<T>,
+    }
+    /// A trait which all wasm resources implement, namely providing the ability to
+    /// drop a resource.
+    ///
+    /// This generally is implemented by generated code, not user-facing code.
+    #[allow(clippy::missing_safety_doc)]
+    pub unsafe trait WasmResource {
+        /// Invokes the `[resource-drop]...` intrinsic.
+        unsafe fn drop(handle: u32);
+    }
+    impl<T: WasmResource> Resource<T> {
+        #[doc(hidden)]
+        pub unsafe fn from_handle(handle: u32) -> Self {
+            debug_assert!(handle != u32::MAX);
+            Self {
+                handle: AtomicU32::new(handle),
+                _marker: marker::PhantomData,
+            }
+        }
+        /// Takes ownership of the handle owned by `resource`.
+        ///
+        /// Note that this ideally would be `into_handle` taking `Resource<T>` by
+        /// ownership. The code generator does not enable that in all situations,
+        /// unfortunately, so this is provided instead.
+        ///
+        /// Also note that `take_handle` is in theory only ever called on values
+        /// owned by a generated function. For example a generated function might
+        /// take `Resource<T>` as an argument but then call `take_handle` on a
+        /// reference to that argument. In that sense the dynamic nature of
+        /// `take_handle` should only be exposed internally to generated code, not
+        /// to user code.
+        #[doc(hidden)]
+        pub fn take_handle(resource: &Resource<T>) -> u32 {
+            resource.handle.swap(u32::MAX, Relaxed)
+        }
+        #[doc(hidden)]
+        pub fn handle(resource: &Resource<T>) -> u32 {
+            resource.handle.load(Relaxed)
+        }
+    }
+    impl<T: WasmResource> fmt::Debug for Resource<T> {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            f.debug_struct("Resource").field("handle", &self.handle).finish()
+        }
+    }
+    impl<T: WasmResource> Drop for Resource<T> {
+        fn drop(&mut self) {
+            unsafe {
+                match self.handle.load(Relaxed) {
+                    u32::MAX => {}
+                    other => T::drop(other),
+                }
+            }
+        }
+    }
+    pub use alloc_crate::boxed::Box;
+    #[cfg(target_arch = "wasm32")]
+    pub fn run_ctors_once() {
+        wit_bindgen_rt::run_ctors_once();
+    }
+    pub unsafe fn cabi_dealloc(ptr: *mut u8, size: usize, align: usize) {
+        if size == 0 {
+            return;
+        }
+        let layout = alloc::Layout::from_size_align_unchecked(size, align);
+        alloc::dealloc(ptr, layout);
+    }
+    extern crate alloc as alloc_crate;
+    pub use alloc_crate::alloc;
+}
+/// Generates `#[unsafe(no_mangle)]` functions to export the specified type as
+/// the root implementation of all generated traits.
+///
+/// For more information see the documentation of `wit_bindgen::generate!`.
+///
+/// ```rust
+/// # macro_rules! export{ ($($t:tt)*) => (); }
+/// # trait Guest {}
+/// struct MyType;
+///
+/// impl Guest for MyType {
+///     // ...
+/// }
+///
+/// export!(MyType);
+/// ```
+#[allow(unused_macros)]
+#[doc(hidden)]
+macro_rules! __export_wacc_impl {
+    ($ty:ident) => {
+        self::export!($ty with_types_in self);
+    };
+    ($ty:ident with_types_in $($path_to_types_root:tt)*) => {
+        $($path_to_types_root)*::
+        exports::comrade::api::api::__export_comrade_api_api_cabi!($ty with_types_in
+        $($path_to_types_root)*:: exports::comrade::api::api);
+    };
+}
+#[doc(inline)]
+pub(crate) use __export_wacc_impl as export;
+#[cfg(target_arch = "wasm32")]
+#[unsafe(
+    link_section = "component-type:wit-bindgen:0.41.0:comrade:api:wacc:encoded world"
+)]
+#[doc(hidden)]
+#[allow(clippy::octal_escapes)]
+pub static __WIT_BINDGEN_COMPONENT_TYPE: [u8; 632] = *b"\
+\0asm\x0d\0\x01\0\0\x19\x16wit-component-encoding\x04\0\x07\xfd\x03\x01A\x02\x01\
+A\x07\x01B\x04\x01@\x01\x07messages\x01\0\x04\0\x03log\x01\0\x01@\0\0}\x04\0\x0b\
+random-byte\x01\x01\x03\0\x11comrade:api/utils\x05\0\x01B\x0e\x01m\x02\x07curren\
+t\x08proposed\x04\0\x06either\x03\0\0\x01p}\x01r\x02\x04data\x02\x04hints\x04\0\x06\
+binary\x03\0\x03\x01r\x02\x04datas\x04hints\x04\0\x03str\x03\0\x05\x01q\x04\x03b\
+in\x01\x04\0\x03str\x01\x06\0\x07success\x01y\0\x07failure\x01s\0\x04\0\x05value\
+\x03\0\x07\x01@\x03\x06choice\x01\x03keys\x05value\x08\0\x08\x04\0\x03put\x01\x09\
+\x01k\x08\x01@\x02\x06choice\x01\x03keys\0\x0a\x04\0\x03get\x01\x0b\x03\0\x11com\
+rade:api/pairs\x05\x01\x02\x03\0\x01\x05value\x01B\x0e\x02\x03\x02\x01\x02\x04\0\
+\x05value\x03\0\0\x04\0\x03api\x03\x01\x01i\x02\x01@\0\0\x03\x04\0\x10[construct\
+or]api\x01\x04\x01h\x02\x01j\0\x01s\x01@\x02\x04self\x05\x06scripts\0\x06\x04\0\x16\
+[method]api.try-unlock\x01\x07\x01k\x01\x01j\x01\x08\x01s\x01@\x02\x04self\x05\x04\
+locks\0\x09\x04\0\x14[method]api.try-lock\x01\x0a\x04\0\x0fcomrade:api/api\x05\x03\
+\x04\0\x10comrade:api/wacc\x04\0\x0b\x0a\x01\0\x04wacc\x03\0\0\0G\x09producers\x01\
+\x0cprocessed-by\x02\x0dwit-component\x070.227.1\x10wit-bindgen-rust\x060.41.0";
+#[inline(never)]
+#[doc(hidden)]
+pub fn __link_custom_section_describing_imports() {
+    wit_bindgen_rt::maybe_link_cabi_realloc();
+}
diff --git a/crates/comrade-component/src/kv.rs b/crates/comrade-component/src/kv.rs
new file mode 100644
index 0000000..7fe1476
--- /dev/null
+++ b/crates/comrade-component/src/kv.rs
@@ -0,0 +1,67 @@
+use crate::bindings::comrade::api::{
+    pairs::{self, get, put, Binary, Str},
+    utils::log,
+};
+use comrade_reference::{Pairs, Value};
+
+#[derive(Default, Clone, Debug)]
+pub(crate) struct Current;
+
+#[derive(Default, Clone, Debug)]
+pub(crate) struct Proposed;
+
+impl Pairs for Current {
+    fn get(&self, key: &str) -> Option<Value> {
+        get(pairs::Either::Current, key)
+            .map(|v| v.into())
+            .or_else(|| {
+                log(&format!("Current Key not found: {key}"));
+                None
+            })
+    }
+
+    fn put(&mut self, key: &str, value: &Value) -> Option<Value> {
+        log(&format!("Putting key: {key} value: {value:?}"));
+        let val = put(pairs::Either::Current, key, &value.clone().into());
+        Some(val.into())
+    }
+}
+
+impl Pairs for Proposed {
+    fn get(&self, key: &str) -> Option<Value> {
+        get(pairs::Either::Proposed, key)
+            .map(|v| v.into())
+            .or_else(|| {
+                log(&format!("Proposed Key not found: {key}"));
+                None
+            })
+    }
+
+    fn put(&mut self, key: &str, value: &Value) -> Option<Value> {
+        log(&format!("Putting key: {key} value: {value:?}"));
+        let val = put(pairs::Either::Proposed, key, &value.clone().into());
+        Some(val.into())
+    }
+}
+
+impl From<pairs::Value> for Value {
+    fn from(value: crate::bindings::comrade::api::pairs::Value) -> Self {
+        match value {
+            pairs::Value::Str(Str { data, hint }) => Value::Str { hint, data },
+            pairs::Value::Bin(Binary { data, hint }) => Value::Bin { hint, data },
+            pairs::Value::Success(value) => Value::Success(value.try_into().unwrap()),
+            pairs::Value::Failure(msg) => Value::Failure(msg),
+        }
+    }
+}
+
+impl From<Value> for pairs::Value {
+    fn from(value: Value) -> Self {
+        match value {
+            Value::Str { hint, data } => pairs::Value::Str(Str { hint, data }),
+            Value::Bin { hint, data } => pairs::Value::Bin(Binary { hint, data }),
+            Value::Success(value) => pairs::Value::Success(value.try_into().unwrap()),
+            Value::Failure(msg) => pairs::Value::Failure(msg),
+        }
+    }
+}
diff --git a/crates/comrade-component/src/lib.rs b/crates/comrade-component/src/lib.rs
new file mode 100644
index 0000000..4b4ccf7
--- /dev/null
+++ b/crates/comrade-component/src/lib.rs
@@ -0,0 +1,57 @@
+#[allow(warnings)]
+mod bindings;
+
+mod kv;
+mod logger;
+mod random;
+
+use crate::{
+    kv::{Current, Proposed},
+    logger::Logger,
+};
+use bindings::comrade::api::pairs;
+use bindings::comrade::api::utils::log;
+use bindings::exports::comrade::api::api::Guest;
+use bindings::exports::comrade::api::api::GuestApi;
+use comrade_reference::Context;
+use std::cell::RefCell;
+
+struct Api {
+    context: RefCell<Context<'static, 'static>>,
+}
+
+impl Guest for Api {
+    type Api = Self;
+}
+
+impl GuestApi for Api {
+    fn new() -> Self {
+        log("Creating new Component");
+
+        Self {
+            context: RefCell::new(Context::new(&Current, &Proposed, &Logger)),
+        }
+    }
+
+    fn try_unlock(&self, unlock: String) -> Result<(), String> {
+        log("[component] try_unlock(..)");
+        self.context.borrow_mut().run(&unlock).map_err(|e| {
+            log(&format!("Error running unlock script: {e}"));
+            format!("Error running unlock script: {e}")
+        })?;
+        Ok(())
+    }
+
+    fn try_lock(&self, lock: String) -> Result<Option<pairs::Value>, String> {
+        log(&format!("try_lock script: {lock}"));
+        self.context.borrow_mut().run(&lock).map_err(|e| {
+            log(&format!("Error running lock script: {e}"));
+            format!("Error running lock script: {e}")
+        })?;
+        // return rstack
+        let rstack = self.context.borrow_mut().rstack();
+        Ok(rstack.map(|v| v.into()))
+    }
+}
+
+bindings::export!(Api with_types_in bindings);
diff --git a/crates/comrade-component/src/logger.rs b/crates/comrade-component/src/logger.rs
new file mode 100644
index 0000000..64c326a
--- /dev/null
+++ b/crates/comrade-component/src/logger.rs
@@ -0,0 +1,10 @@
+use crate::bindings::comrade::api::utils::log;
+use comrade_reference::Log;
+
+pub(crate) struct Logger;
+
+impl Log for Logger {
+    fn log(&self, msg: &str) {
+        log(msg);
+    }
+}
diff --git a/crates/comrade-component/src/random.rs b/crates/comrade-component/src/random.rs
new file mode 100644
index 0000000..7a313ba
--- /dev/null
+++ b/crates/comrade-component/src/random.rs
@@ -0,0 +1,37 @@
+//! Implements random for this wasm32-unknown-unknown target.
+//!
+//! Since we was wasm but ARE NOT int he browser, we need to use the
+//! custom function to generate random bytes.
+//!
+//! However, since getrandom v0.2 and v0.3 are both present in dependencies,
+//! and have different APIs, we need to implement both of them.
+use super::bindings::comrade::api::utils::random_byte;
+
+/// getrandom v0.2 requires the 'cusotm' flag and this custom function to use the import for random byte generation.
+///
+/// We do this is because "js" feature is incompatible with the component model
+/// if you ever got the __wbindgen_placeholder__ error when trying to use the `js` feature
+/// of getrandom,
+pub fn imported_random(dest: &mut [u8]) -> Result<(), getrandom::Error> {
+    // iterate over the length of the destination buffer and fill it with random bytes
+    (0..dest.len()).for_each(|i| {
+        dest[i] = random_byte();
+    });
+
+    Ok(())
+}
+
+// for getrandom v0.2 custom function
+getrandom::register_custom_getrandom!(imported_random);
+
+/// getrandom v0.3 requires the 'custom' RUSTFLAG and this function below:
+#[unsafe(no_mangle)]
+pub unsafe extern "Rust" fn __getrandom_v03_custom(
+    dest: *mut u8,
+    len: usize,
+) -> Result<(), getrandom::Error> {
+    // Safety: This is safe because we are using the imported_random function
+    // which is safe to use in this context.
+    let slice = unsafe { std::slice::from_raw_parts_mut(dest, len) };
+    imported_random(slice)
+}
diff --git a/crates/comrade-component/wit/world.wit b/crates/comrade-component/wit/world.wit
new file mode 100644
index 0000000..11dfed5
--- /dev/null
+++ b/crates/comrade-component/wit/world.wit
@@ -0,0 +1,97 @@
+package comrade:api;
+
+interface api {
+    use pairs.{value};
+
+    /// The main API resource 
+    resource api {
+        /// The main API function
+        constructor();
+
+        /// Set the unlock script Fails if the script is not valid.
+        try-unlock: func(script: string) -> result<_, string>;
+
+        /// Tries a lock script 
+        try-lock: func(lock: string) -> result<option<value>, string>;
+    }
+}
+
+interface pairs {
+
+  /// Returns the value of the resource. 
+  put: func(choice: either, key: string, value: value) -> value;
+
+  /// Returns the value of the resource. 
+  /// Get a value from the given key, if it exists.
+  /// Returns some value or None.
+  get: func(choice: either, key: string) -> option<value>;
+
+  /// Either current or proposed 
+  enum either {
+    /// The current kv pairs
+    current,
+
+    /// The proposed kv pairs 
+    proposed
+  }
+
+  /// A binary value and associated hint 
+  record binary {
+    /// The binary value
+    data: list<u8>,
+
+    /// A hint for the binary value
+    hint: string
+  }
+
+  /// A string value and associated hint 
+  record str {
+    /// The string value
+    data: string,
+
+    /// A hint for the string value
+    hint: string
+  }
+
+  /// A variant representing the different types of values that can be stored.
+  variant value {
+    /// A binary value 
+    bin(binary),
+
+    /// A string value 
+    str(str),
+
+    /// Success value 
+    success(u32),
+
+    /// Failure value 
+    failure(string)
+  }
+
+}
+
+interface utils {
+    /// Logs some output from the guest component.
+    log: func(message: string);
+
+    /// Get a random byte from the host system
+    random-byte: func() -> u8;
+}
+
+interface env {
+    now: func() -> u64;
+}
+
+/// An example world for the component to target.
+world wacc {
+  
+    /// Utilities provided by host
+    import utils;
+
+    import pairs;
+    /// Re-exports the `pairs` interface for the VM
+    // export pairs;
+
+    /// Export the main api for the component 
+    export api;
+}
diff --git a/crates/comrade-reference/Cargo.toml b/crates/comrade-reference/Cargo.toml
new file mode 100644
index 0000000..e30f936
--- /dev/null
+++ b/crates/comrade-reference/Cargo.toml
@@ -0,0 +1,25 @@
+[package]
+name = "comrade-reference"
+version.workspace = true
+edition.workspace = true
+authors.workspace = true
+description.workspace = true
+readme.workspace = true
+license.workspace = true
+
+[dependencies]
+multikey = { workspace = true }
+multihash.workspace = true
+multisig.workspace = true
+multiutil.workspace = true
+pest = "2.8"
+pest_derive = "2.8"
+thiserror = "2.0"
+
+[dev-dependencies]
+hex = "0.4"
+rand = "0.8.5"
+chrono = { version = "0.4.19", default-features = false, features = ["clock"] }
+
+[lints]
+workspace = true
diff --git a/crates/comrade-reference/README.md b/crates/comrade-reference/README.md
new file mode 100644
index 0000000..5027b53
--- /dev/null
+++ b/crates/comrade-reference/README.md
@@ -0,0 +1,17 @@
+# Comrade Verification Runtime -  Reference Implementation
+
+An opinionated script runtime for lock and unlock scripts. Since scripts are just plain text, they need to be executed "somewhere, somehow" and this can be done by various means. For example, in previous versions of Comrade, the Rhai scripting engine was used to execute the scripts. This could be done using other scripting languages such as Lua, but in this implementation, a domain specific language (DSL) parser is used to interpret and run the scripts.
+
+## Script Runtime & Script Parser
+
+This crate contains the parser, abstract syntax tree, and runtime to execute the scripts. In this implementation, a simple Domain Specific Language (DSL) parser is written in [pest](https://pest.rs/book/intro.html), and then the abstract syntax tree is executed against corresponding Rust functions. In other words, when `check_signature(..)` appears in a script, the runtime calls the `check_signature` cryptographic construct in Rust to evaluate whether the script is valid or not.
+
+## Comrade Crypto Constructs
+
+This implementation calls associated cryptographic constructs to verify the validity of the scripts against each other. This is the reference implementation for the [comrade](../comrade) and [comrade-component](../comrade-component).
+
+If different cryptographic primitives are desired, the crypto dependencies can be changed for new ones, a new component built, and run with bettersign.
+
+## Design Considerations 
+
+This comrade architecture was chosen to give users maximum flexibility, upgradeability, and extensibility of the backend. Because of the modular approach, backends can be switched out without impacting the rest of the system. This makes open source more viable and maintainable, since components can be used interchangeably without placing the entire maintenance burden on a single user.
diff --git a/crates/comrade-reference/src/context.rs b/crates/comrade-reference/src/context.rs
new file mode 100644
index 0000000..845de75
--- /dev/null
+++ b/crates/comrade-reference/src/context.rs
@@ -0,0 +1,681 @@
+//! The context that is built and where the script
+//! is evaluated
+
+mod pairs;
+pub use pairs::Pairs;
+
+mod value;
+pub use value::Value;
+
+mod stack;
+pub use stack::{Stack, Stk};
+
+mod parser;
+pub(crate) use parser::Rule;
+use parser::{parse, Expression, Function, Key};
+
+use crate::ApiError;
+use multihash::{mh, Multihash};
+use multikey::{Multikey, Views as _};
+use multisig::Multisig;
+use multiutil::prelude::*;
+
+/// The [Context] within which the script is
+/// evaluated.
+pub struct Context<'un, 'lo> {
+    /// The current key value Pairs already in the context
+    pub(crate) current: &'un dyn Pairs,
+
+    /// The proposed key value Pairs to be evaluated
+    pub(crate) proposed: &'lo dyn Pairs,
+
+    /// The number of checks that have been performed
+    pub(crate) check_count: usize,
+
+    /// The Return stack
+    pub(crate) rstack: Stk,
+
+    /// The Parameters stack
+    pub(crate) pstack: Stk,
+
+    /// Optional domain segment of the /branch/leaf/ key-path. Defaults to "/".
+    pub domain: String,
+
+    /// The log implementation for the context
+    pub(crate) logger: &'un dyn Log,
+}
+
+/// Log a message to the console
+pub trait Log {
+    fn log(&self, msg: &str);
+}
+
+impl<'un, 'lo> Context<'un, 'lo> {
+    /// Create a new [Context] struct with the given [Current] and [Proposed] key-value stores,
+    /// which are bound by both [Pairs].
+    pub fn new(current: &'un impl Pairs, proposed: &'lo impl Pairs, logger: &'un impl Log) -> Self {
+        Context {
+            current,
+            proposed,
+            check_count: 0,
+            rstack: Stk::default(),
+            pstack: Stk::default(),
+            domain: "/".to_string(),
+            logger,
+        }
+    }
+
+    /// Set the domain for the context
+    pub fn with_domain(&mut self, domain: &str) -> &mut Self {
+        self.domain = domain.to_string();
+        self
+    }
+
+    /// Parse a script from a string and evaluate it, returning the result
+    pub fn run(&mut self, script: &str) -> Result<bool, ApiError> {
+        self.logger.log(&format!("Running script: {script}"));
+        let expressions = parse(script)?;
+
+        if expressions.is_empty() {
+            return Ok(false);
+        }
+
+        // Execute each expression in sequence
+        // For multiple expressions (separated by semicolons in the original script),
+        // we execute all of them and return the result of the last one
+        let mut result = false;
+
+        for expr in &expressions {
+            result = self.eval(expr);
+            // Unlike logical OR, we don't short-circuit between separate statements
+        }
+
+        Ok(result)
+    }
+
+    /// Evaluate a single expression
+    fn eval(&mut self, expr: &Expression) -> bool {
+        match expr {
+            Expression::Function(func) => self.eval_function(func),
+            Expression::And(left, right) => self.eval(left) && self.eval(right),
+            Expression::Or(left, right) => self.eval(left) || self.eval(right),
+            Expression::Group(inner) => self.eval(inner),
+        }
+    }
+
+    /// Evaluate a function call
+    fn eval_function(&mut self, function: &Function) -> bool {
+        match function {
+            Function::CheckEq(key) => match key {
+                Key::Branch(key) => self.check_eq(&self.branch(key)),
+                Key::String(key) => self.check_eq(key),
+            },
+            Function::CheckSignature(key, msg) => match key {
+                Key::Branch(key) => self.check_signature(&self.branch(key), msg),
+                Key::String(key) => self.check_signature(key, msg),
+            },
+            Function::CheckPreimage(preimage) => match preimage {
+                Key::Branch(key) => self.check_preimage(&self.branch(key)),
+                Key::String(key) => self.check_preimage(key),
+            },
+            Function::Push(path) => match path {
+                Key::Branch(key) => self.push(&self.branch(key)),
+                Key::String(key) => self.push(key),
+            },
+        }
+    }
+
+    /// Check the signature of the given key str
+    pub fn check_signature(&mut self, key: &str, msg: &str) -> bool {
+        self.logger.log(&format!("check_signature({key}, {msg})"));
+        let current = self.current.get(key);
+        // lookup the keypair for this key
+        let pubkey = {
+            match &current {
+                Some(Value::Bin { hint: _, data }) => match Multikey::try_from(data.as_ref()) {
+                    Ok(mk) => mk,
+                    Err(e) => {
+                        self.logger
+                            .log("check_signature: error decoding multikey: {e}");
+                        return self.check_fail(&e.to_string());
+                    }
+                },
+                Some(_) => {
+                    self.logger
+                        .log("check_signature: unexpected value type associated with {key}");
+                    return self
+                        .check_fail(&format!("unexpected value type associated with {key}"));
+                }
+                None => {
+                    self.logger.log(&format!(
+                        "check_signature: no multikey associated with {key}"
+                    ));
+                    return self.check_fail(&format!("no multikey associated with {key}"));
+                }
+            }
+        };
+
+        self.logger
+            .log(&format!("OK check_signature: pubkey: {pubkey:?}"));
+
+        // look up the message that was signed
+        let message = {
+            match self.proposed.get(msg) {
+                Some(Value::Bin { hint: _, data }) => data,
+                Some(Value::Str { hint: _, data }) => data.as_bytes().to_vec(),
+                Some(_) => {
+                    self.logger
+                        .log("check_signature: unexpected value type associated with {msg}");
+                    return self
+                        .check_fail(&format!("unexpected value type associated with {msg}"));
+                }
+                None => {
+                    self.logger
+                        .log("check_signature: no message associated with {msg}");
+                    return self.check_fail(&format!("no message associated with {msg}"));
+                }
+            }
+        };
+
+        self.logger
+            .log(&format!("OK check_signature: message: {message:?}"));
+
+        // make sure we have at least one parameter on the stack
+        if self.pstack.is_empty() {
+            self.logger.log(&format!(
+                "Err not enough parameters on the stack for check_signature: {}",
+                self.pstack.len(),
+            ));
+            return self.check_fail(&format!(
+                "not enough parameters ({}) on the stack for check_signature ({key}, {msg})",
+                self.pstack.len()
+            ));
+        }
+
+        // peek at the top item and verify that it is a Multisig
+        let sig = {
+            match self.pstack.top() {
+                Some(Value::Bin { hint: _, data }) => {
+                    self.logger.log(&format!(
+                        "check_signature: found multisig on stack: {data:?}"
+                    ));
+                    match Multisig::try_from(data.as_ref()) {
+                        Ok(sig) => sig,
+                        Err(e) => return self.check_fail(&e.to_string()),
+                    }
+                }
+                _ => return self.check_fail("no multisig on stack"),
+            }
+        };
+
+        // get the verify view
+        let verify_view = match pubkey.verify_view() {
+            Ok(v) => v,
+            Err(e) => return self.check_fail(&e.to_string()),
+        };
+
+        // verify the signature
+        match verify_view.verify(&sig, Some(message.as_ref())) {
+            Ok(_) => {
+                // the signature verification worked so pop the signature arg off
+                // of the stack before continuing
+                self.logger.log("check_signature: signature verified");
+                self.pstack.pop();
+                self.succeed()
+            }
+            Err(e) => {
+                self.logger.log("check_signature({key}, {msg}) -> false");
+                self.check_fail(&e.to_string())
+            }
+        }
+    }
+
+    /// Check the preimage of the given key
+    pub fn check_preimage(&mut self, key: &str) -> bool {
+        // look up the hash and try to decode it
+        let hash = {
+            let current = self.current.get(key);
+            match current {
+                Some(Value::Bin { hint: _, data }) => match Multihash::try_from(data.as_ref()) {
+                    Ok(hash) => hash,
+                    Err(e) => return self.check_fail(&e.to_string()),
+                },
+                Some(_) => {
+                    return self
+                        .check_fail(&format!("unexpected value type associated with {key}"));
+                }
+                None => return self.check_fail(&format!("kvp missing key: {key}")),
+            }
+        };
+
+        // make sure we have at least one parameter on the stack
+        if self.pstack.is_empty() {
+            self.logger.log(&format!(
+                "not enough parameters on the stack for check_preimage: {}",
+                self.pstack.len(),
+            ));
+            return self.check_fail(&format!(
+                "not enough parameters on the stack for check_preimage: {}",
+                self.pstack.len()
+            ));
+        }
+
+        // get the preimage data from the stack
+        let preimage = {
+            match self.pstack.top() {
+                Some(Value::Bin { data, hint: _ }) => {
+                    match mh::Builder::new_from_bytes(hash.codec(), data) {
+                        Ok(builder) => match builder.try_build() {
+                            Ok(hash) => hash,
+                            Err(e) => return self.check_fail(&e.to_string()),
+                        },
+                        Err(e) => return self.check_fail(&e.to_string()),
+                    }
+                }
+                Some(Value::Str { hint: _, data }) => {
+                    match mh::Builder::new_from_bytes(hash.codec(), data.as_bytes()) {
+                        Ok(builder) => match builder.try_build() {
+                            Ok(hash) => hash,
+                            Err(e) => return self.check_fail(&e.to_string()),
+                        },
+                        Err(e) => return self.check_fail(&e.to_string()),
+                    }
+                }
+                _ => return self.check_fail("no multihash data on stack"),
+            }
+        };
+
+        // check that the hashes match
+        if hash == preimage {
+            // the hash check passed so pop the argument from the stack
+            let _ = self.pstack.pop();
+            self.succeed()
+        } else {
+            // the hashes don't match
+            self.check_fail("preimage doesn't match")
+        }
+    }
+
+    /// Verifies the top of the stack matches the value associated with the key
+    pub fn check_eq(&mut self, key: &str) -> bool {
+        // look up the value associated with the key
+        let value = {
+            match self.current.get(key) {
+                Some(Value::Bin { hint: _, data }) => data,
+                Some(Value::Str { hint: _, data }) => data.as_bytes().to_vec(),
+                _ => {
+                    self.logger.log("check_eq: no value associated with {key}");
+                    return self.check_fail(&format!("kvp missing key: {key}"));
+                }
+            }
+        };
+
+        // make sure we have at least one parameter on the stack
+        if self.pstack.is_empty() {
+            self.logger.log(&format!(
+                "not enough parameters on the stack for check_eq: {}",
+                self.pstack.len(),
+            ));
+            return self.check_fail(&format!(
+                "not enough parameters on the stack for check_eq: {}",
+                self.pstack.len()
+            ));
+        }
+
+        let stack_value = {
+            match self.pstack.top() {
+                Some(Value::Bin { hint: _, data }) => data,
+                Some(Value::Str { hint: _, data }) => data.as_bytes().to_vec(),
+                _ => {
+                    self.logger.log("check_eq: no value on the stack");
+                    return self.check_fail("no value on the stack");
+                }
+            }
+        };
+
+        // check if equal
+        if value == stack_value {
+            // the values match so pop the argument from the stack
+            let _ = self.pstack.pop();
+            self.succeed()
+        } else {
+            // the values don't match
+            self.check_fail("values don't match")
+        }
+    }
+
+    /// Increment the check counter and to push a FAILURE marker on the return stack
+    pub fn check_fail(&mut self, err: &str) -> bool {
+        self.logger.log(&format!("check_fail ({err})"));
+        // update the context check_count
+        self.check_count += 1;
+        // fail
+        self.fail(err)
+    }
+
+    /// Increment the check counter and to push a FAILURE marker on the return stack
+    pub fn fail(&mut self, err: &str) -> bool {
+        // push the FAILURE onto the return stack
+        self.rstack.push(Value::Failure(err.to_string()));
+        false
+    }
+
+    /// Push a SUCCESS marker onto the return stack
+    pub fn succeed(&mut self) -> bool {
+        self.logger
+            .log(&format!("succeed() -> {}", self.check_count));
+        // push the SUCCESS marker with the check count
+        self.rstack.push(self.check_count.into());
+        // return that we succeeded
+        true
+    }
+
+    /// Push the value associated with the key onto the parameter stack
+    pub fn push(&mut self, key: &str) -> bool {
+        self.logger.log(&format!("PUSHING: push(\"{key}\")"));
+        // try to look up the key-value pair by key and push the result onto the stack
+        match self.proposed.get(key) {
+            Some(v) => {
+                self.logger
+                    .log(&format!("push: found value associated with {key}"));
+                self.pstack.push(v.clone());
+                true
+            }
+            None => {
+                self.logger
+                    .log(&format!("push: no value associated with {key}"));
+                self.fail(&format!("kvp missing key: {key}"))
+            }
+        }
+    }
+
+    /// Calculate the full key given the context
+    /// Concatenates the branch key-path with the provided key-path to create a key-path argument for other functions.
+    /// When used in lock scripts, the branch key-path is the key-path the lock script is associated with.
+    /// When used in unlock scripts, the branch key-path is always /. This function fails if used in a lock script associated with a leaf
+    pub fn branch(&self, key: &str) -> String {
+        let s = format!("{}{}", self.domain, key);
+        self.logger
+            .log(&format!("branch({}) -> {}", key, s.as_str()));
+        s
+    }
+
+    /// Returns the top of the return stack
+    pub fn rstack(&self) -> Option<Value> {
+        self.rstack.top()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use super::*;
+    use crate::context::Context;
+    use std::collections::HashMap;
+
+    struct TestLogger;
+
+    impl Log for TestLogger {
+        fn log(&self, msg: &str) {
+            println!("{msg}");
+        }
+    }
+
+    #[derive(Clone, Debug, Default)]
+    struct ContextPairs(HashMap<String, Value>);
+
+    impl Pairs for ContextPairs {
+        fn get(&self, key: &str) -> Option<Value> {
+            self.0.get(key).cloned()
+        }
+
+        fn put(&mut self, key: &str, value: &Value) -> Option<Value> {
+            self.0.insert(key.to_string(), value.clone())
+        }
+    }
+
+    fn unlock_script(entry_key: &str, proof_key: &str) -> String {
+        let unlock_script = format!(
+            r#"
+                // push the serialized Entry as the message
+                push("{entry_key}"); 
+
+                // push the proof data
+                push("{proof_key}");
+            "#
+        );
+
+        unlock_script
+    }
+
+    /// First lock is /ephemeral and {entry_key}
+    fn first_lock_script(entry_key: &str) -> String {
+        let first_lock = format!(
+            r#"
+                // check the first key, which is ephemeral
+                check_signature("/ephemeral", "{entry_key}") 
+            "#
+        );
+
+        first_lock
+    }
+
+    /// Other lock script
+    fn other_lock_script(entry_key: &str) -> String {
+        format!(
+            r#"
+                // then check a possible threshold sig...
+                check_signature("/recoverykey", "{entry_key}") ||
+
+                // then check a possible pubkey sig...
+                check_signature("/pubkey", "{entry_key}") ||
+                
+                // then the pre-image proof...
+                check_preimage("/hash")
+            "#
+        )
+    }
+    #[test]
+    fn test_push_pairs() {
+        let entry_key = "/entry/";
+
+        // unlock
+        let entry_data = b"for great justice, move every zig!";
+        let proof_key = "/entry/proof";
+        let proof_data = hex::decode("4819397f51b18bc6cffd1fff07afa33f7096c7a0c659590b077cc0ea5d6081d739512129becacb8e6997e6b7d18756299f515a822344ac2b6737979d5e5e6b03").unwrap();
+
+        let unlock = format!(
+            r#"
+        // push the serialized Entry as the message
+        push("{entry_key}");
+
+        // push the proof data
+        push("{entry_key}proof");
+    "#
+        );
+
+        let mut kvp_unlock = ContextPairs::default();
+        // only used for check_signature msg (2ns parameter)
+        let kvp_lock = ContextPairs::default();
+
+        let entry_data_vec = entry_data.to_vec();
+
+        kvp_unlock.put(entry_key, &entry_data_vec.clone().into());
+        kvp_unlock.put(proof_key, &proof_data.clone().into());
+
+        let mut ctx = Context::new(&kvp_lock, &kvp_unlock, &TestLogger);
+
+        // When the unlock script runs,
+        // there should be 2 values on the pstack
+        // one for /entry/
+        // and one for /entry/proof
+
+        // Run the unlock script
+        let result = ctx.run(&unlock);
+        assert!(result.is_ok());
+
+        // Check the pstack
+        // The first value should be the entry key
+        // The second value should be the proof key
+        let mut pstack = ctx.pstack.clone();
+        assert_eq!(pstack.len(), 2);
+        assert_eq!(pstack.pop().unwrap(), proof_data.into());
+        assert_eq!(pstack.pop().unwrap(), entry_data_vec.into());
+    }
+
+    #[test]
+    fn test_eval_scripts() {
+        // unlock
+        let entry_key = "/entry/";
+
+        let entry_data = b"for great justice, move every zig!";
+        let proof_key = "/entry/proof";
+        let proof_data = hex::decode("b92483a6c00600010040eda2eceac1ef60c4d54efc7b50d86b198ba12358749e5069dbe0a5ca6c3e7e78912a21c67a18a4a594f904e7df16f798d929d7a8cee57baca89b4ed0dfd1c801").unwrap();
+
+        let mut kvp_lock = ContextPairs::default();
+        let mut kvp_unlock = ContextPairs::default();
+        // "/entry/" needs to be present on both lock and unlock stacks,
+        // since they are used in both the unlock and lock scripts:
+        // ie. push("/entry/") and check_signature("/pubkey", "/entry/")
+        kvp_unlock.put(entry_key, &entry_data.to_vec().into());
+        kvp_lock.put(entry_key, &entry_data.to_vec().into());
+        // "/entry/proof" only needs to be present on the unlock stack,
+        // since that's where the proof is used
+        kvp_unlock.put(proof_key, &proof_data.clone().into());
+
+        let unlock = unlock_script(entry_key, proof_key);
+
+        let first_lock = first_lock_script(entry_key);
+        let other_lock = other_lock_script(entry_key);
+
+        let locks = [first_lock, other_lock];
+
+        // lock
+        let pubkey = "/pubkey";
+        let pub_key = hex::decode("ba24ed010874657374206b657901012069c9e8cd599542b5ff7e4cdc4265847feb9785330557edd6a9edae741ed4c3b2").unwrap();
+        // "/pubkey" only needs to be present on unlock stack,
+        kvp_lock.put(pubkey, &pub_key.into());
+
+        // If we run the unlock script, then the lock script
+        // the results of check_signature should be true
+        // since our signature is valid
+        let mut ctx = Context::new(&kvp_lock, &kvp_unlock, &TestLogger);
+        let result = ctx.run(&unlock);
+        assert!(result.is_ok());
+
+        // Check the pstack
+        // The first value should be the entry key
+        // The second value should be the proof key
+        let mut pstack = ctx.pstack.clone();
+        assert_eq!(pstack.len(), 2);
+        assert_eq!(pstack.pop().unwrap(), proof_data.into());
+        assert_eq!(pstack.pop().unwrap(), entry_data.to_vec().into());
+
+        // Now run the first lock script
+        // The first lock script should run, but fail
+        // since we didn't provide a signature for /ephemeral
+        let result = ctx.run(&locks[0]);
+        assert!(result.is_ok());
+
+        // Check the return stack
+        // The length should be 1
+        // The value should be Failure("no multikey associated with /ephemeral")
+        assert_eq!(ctx.rstack.len(), 1);
+        assert_eq!(
+            ctx.rstack.top().unwrap(),
+            Value::Failure("no multikey associated with /ephemeral".to_string())
+        );
+
+        // Now run the second lock script
+        let result = ctx.run(&locks[1]);
+        assert!(result.is_ok());
+
+        // Check the return stack
+        // The length should be 3:
+        // - the first lock script failure, since we didn't provide a signature for /ephemeral
+        // - the second lock script failure, since we provided a valid signature for /recoverykey
+        // - the third lock script success, since we provided a valid signature for /pubkey
+        // The value should be Success(2)
+        // - since we had 2 failed checks
+        eprintln!("Return stack: {:?}", ctx.rstack);
+        assert_eq!(ctx.rstack.len(), 3);
+        assert_eq!(ctx.rstack.top().unwrap(), Value::Success(2));
+    }
+
+    #[test]
+    fn generate_test_signatures() {
+        use multikey::Views as _;
+        use multikey::{self};
+        use multisig::Views as _;
+        use multiutil::prelude::*;
+
+        let seed = hex::decode("f9ddcd5118319cc69e6985ef3f4ee3b6c591d46255e1ae5569c8662111b7d3c2")
+            .unwrap();
+
+        let mk = multikey::Builder::new_from_seed(Codec::Ed25519Priv, seed.as_slice())
+            .unwrap()
+            .with_comment("test key")
+            .try_build()
+            .unwrap();
+
+        let entry_data = b"for great justice, move every zig!";
+
+        eprintln!("Entry data: {entry_data:?}");
+
+        let signmk = mk.sign_view().unwrap();
+
+        let signature = signmk.sign(entry_data.as_slice(), false, None).unwrap();
+
+        let sig_bytes_raw: Vec<u8> = signature.clone().into();
+        eprintln!("Signature bytes: {:?}", &sig_bytes_raw);
+        let raw_hex = hex::encode(sig_bytes_raw.clone());
+        eprintln!("Signature bytes RAW HEX: {raw_hex}");
+        let ms_from_raw = Multisig::try_from(sig_bytes_raw.as_slice()).unwrap();
+
+        // assert hex matches b92483a6c006000100404819397f51b18bc6cffd1fff07afa33f7096c7a0c659590b077cc0ea5d6081d739512129becacb8e6997e6b7d18756299f515a822344ac2b6737979d5e5e6b03
+        assert_eq!(
+            raw_hex,
+            "b92483a6c006000100404819397f51b18bc6cffd1fff07afa33f7096c7a0c659590b077cc0ea5d6081d739512129becacb8e6997e6b7d18756299f515a822344ac2b6737979d5e5e6b03"
+        );
+
+        // verify with ms_from_raw
+        let verify_mk = mk.verify_view().unwrap();
+        assert!(verify_mk
+            .verify(&ms_from_raw, Some(entry_data.as_ref()))
+            .is_ok());
+
+        // print out hex signature
+        let sig_data = signature.data_view().unwrap();
+        let sig_bytes = sig_data.sig_bytes().unwrap();
+
+        let ms = multisig::Builder::new(Codec::EddsaMsig)
+            .with_signature_bytes(&sig_bytes)
+            .try_build()
+            .unwrap();
+
+        let hex_sig = hex::encode(ms.data_view().unwrap().sig_bytes().unwrap());
+        // eprintln!("Signature: {hex_sig}");
+
+        assert_eq!(
+            hex_sig,
+            "4819397f51b18bc6cffd1fff07afa33f7096c7a0c659590b077cc0ea5d6081d739512129becacb8e6997e6b7d18756299f515a822344ac2b6737979d5e5e6b03"
+        );
+
+        let verify_mk = mk.verify_view().unwrap();
+        assert!(verify_mk.verify(&ms, Some(entry_data.as_ref())).is_ok());
+
+        // print pubkey
+        let pubkey = mk.conv_view().unwrap();
+        let pubkey_bytes: Vec<u8> = pubkey.to_public_key().unwrap().into();
+
+        eprintln!("Pubkey bytes: {pubkey_bytes:?}");
+        let hex_pubkey = hex::encode(pubkey_bytes.clone());
+
+        eprintln!("Pubkey: {hex_pubkey}");
+
+        assert_eq!(
+            hex_pubkey,
+            "ba24ed010874657374206b657901012054d94d7b8a11d6581af4a14bc6451c7a23049018610f108c996968fe8fce9464"
+        );
+    }
+}
diff --git a/crates/comrade-reference/src/context/pairs.rs b/crates/comrade-reference/src/context/pairs.rs
new file mode 100644
index 0000000..90a470d
--- /dev/null
+++ b/crates/comrade-reference/src/context/pairs.rs
@@ -0,0 +1,11 @@
+use super::value::Value;
+
+/// Trait to a key-value storage mechanism
+pub trait Pairs {
+    /// get a value associated with the key
+    fn get(&self, key: &str) -> Option<Value>;
+
+    /// add a key-value pair to the storage, returns the previous value if the
+    /// key already exists in the data structure
+    fn put(&mut self, key: &str, value: &Value) -> Option<Value>;
+}
diff --git a/crates/comrade-reference/src/context/parser.rs b/crates/comrade-reference/src/context/parser.rs
new file mode 100644
index 0000000..2d4082f
--- /dev/null
+++ b/crates/comrade-reference/src/context/parser.rs
@@ -0,0 +1,503 @@
+// allow unused
+#![allow(unused)]
+
+use pest::iterators::{Pair, Pairs};
+use pest::Parser;
+use pest_derive::Parser;
+
+use crate::error::ApiError;
+
+#[derive(Parser)]
+#[grammar = "context/parser/grammar.pest"]
+pub struct ScriptParser;
+
+/// Our AST defintion in Rust. Each function type is represented by an enum variant.
+#[derive(Debug, Clone, PartialEq)]
+pub enum Function<'a> {
+    /// A function that checks the equality of a key.
+    CheckEq(Key<'a>),
+    /// A function that checks the signature of a key and message.
+    CheckSignature(Key<'a>, &'a str),
+    /// A function that checks the preimage of a key.
+    CheckPreimage(Key<'a>),
+    /// A function that pushes a path to the stack.
+    Push(Key<'a>),
+}
+
+/// The [Function] Key can either be a String or the branch function which returns a String
+#[derive(Debug, Clone, PartialEq)]
+pub(crate) enum Key<'a> {
+    String(&'a str),
+    Branch(&'a str),
+}
+
+/// Represents a complete expression tree
+#[derive(Debug, Clone, PartialEq)]
+pub enum Expression<'a> {
+    Function(Function<'a>),
+    And(Box<Expression<'a>>, Box<Expression<'a>>),
+    Or(Box<Expression<'a>>, Box<Expression<'a>>),
+    Group(Box<Expression<'a>>),
+}
+
+/// Parse a script from a string into expressions
+pub fn parse(script_str: &str) -> Result<Vec<Expression>, ApiError> {
+    let pairs = ScriptParser::parse(Rule::script, script_str)
+        .map_err(|e| ApiError::PestParse(Box::new(e)))?;
+
+    let mut expressions = Vec::new();
+
+    // Find the 'script' node
+    for pair in pairs {
+        if pair.as_rule() == Rule::script {
+            // Process each expression within the script
+            for inner_pair in pair.into_inner() {
+                if inner_pair.as_rule() == Rule::expr {
+                    expressions.push(parse_expression(inner_pair)?);
+                }
+            }
+            break;
+        }
+    }
+
+    // If there are no expressions, that's valid (empty script)
+    Ok(expressions)
+}
+
+/// Parse an expression from a pest pair
+fn parse_expression(pair: Pair<Rule>) -> Result<Expression, ApiError> {
+    match pair.as_rule() {
+        Rule::expr => {
+            let inner = pair.into_inner().next().unwrap();
+            parse_expression(inner)
+        }
+        Rule::or_expr => {
+            let mut inner = pair.into_inner();
+            let first = parse_expression(inner.next().unwrap());
+
+            inner.fold(first, |acc, pair| {
+                // This handles "||" operators
+                Ok(Expression::Or(
+                    Box::new(acc?),
+                    Box::new(parse_expression(pair)?),
+                ))
+            })
+        }
+        Rule::and_expr => {
+            let mut inner = pair.into_inner();
+            let first = parse_expression(inner.next().unwrap());
+
+            inner.fold(first, |acc, pair| {
+                // This handles "&&" operators
+                Ok(Expression::And(
+                    Box::new(acc?),
+                    Box::new(parse_expression(pair)?),
+                ))
+            })
+        }
+        Rule::primary_expr => {
+            let inner = pair.into_inner().next().unwrap();
+            match inner.as_rule() {
+                Rule::function_call => Ok(parse_function(inner)?),
+                Rule::expr => Ok(Expression::Group(Box::new(parse_expression(inner)?))),
+                _ => unreachable!(),
+            }
+        }
+        _ => unreachable!("Unexpected rule: {:?}", pair.as_rule()),
+    }
+}
+
+/// Parse a function call from a pest pair
+fn parse_function(pair: Pair<Rule>) -> Result<Expression, ApiError> {
+    let mut inner = pair.into_inner();
+    let function_name = inner.next().unwrap().as_str();
+
+    // Disallow branch() as a top-level function call
+    if function_name == "branch" {
+        return Err(ApiError::ParseScript(
+            "branch() can only be used as an argument to other functions".to_string(),
+        ));
+    }
+
+    // Parse arguments
+    let mut args = Vec::new();
+    for p in inner {
+        if [Rule::string_literal, Rule::path_literal, Rule::identifier].contains(&p.as_rule()) {
+            // Direct string arguments become Key::String
+            let raw_str = p.as_str();
+            let arg_str =
+                if p.as_rule() == Rule::string_literal || p.as_rule() == Rule::path_literal {
+                    &raw_str[1..raw_str.len() - 1]
+                } else {
+                    raw_str
+                };
+            args.push(Key::String(arg_str));
+        } else if p.as_rule() == Rule::function_call {
+            // Handle nested function calls - only allow branch()
+            let func_pairs = p.clone().into_inner();
+            let nested_func_name = func_pairs.clone().next().unwrap().as_str();
+
+            if nested_func_name == "branch" {
+                // Process branch() argument
+                let branch_args: Vec<&str> = func_pairs
+                    .skip(1) // Skip the function name
+                    .filter_map(|arg| {
+                        if [Rule::string_literal, Rule::path_literal, Rule::identifier]
+                            .contains(&arg.as_rule())
+                        {
+                            let raw_str = arg.as_str();
+                            let arg_str = if arg.as_rule() == Rule::string_literal
+                                || arg.as_rule() == Rule::path_literal
+                            {
+                                &raw_str[1..raw_str.len() - 1]
+                            } else {
+                                raw_str
+                            };
+                            Some(arg_str)
+                        } else {
+                            None
+                        }
+                    })
+                    .collect();
+
+                if branch_args.len() != 1 {
+                    return Err(ApiError::ParseScript(
+                        "branch() requires exactly one argument".to_string(),
+                    ));
+                }
+
+                args.push(Key::Branch(branch_args[0]));
+            } else {
+                return Err(ApiError::ParseScript(format!(
+                    "Only branch() can be used as a nested function: got {}",
+                    nested_func_name
+                )));
+            }
+        }
+    }
+
+    // Create the appropriate Function based on name and arguments
+    let function = match function_name {
+        "check_eq" if args.len() == 1 => Function::CheckEq(args[0].clone()),
+        "check_signature" if args.len() == 2 => {
+            let key = args[0].clone();
+            match &args[1] {
+                Key::String(msg) => Function::CheckSignature(key, msg),
+                Key::Branch(_) => {
+                    return Err(ApiError::ParseScript(
+                        "Branch cannot be used as message argument".to_string(),
+                    ));
+                }
+            }
+        }
+        "check_preimage" if args.len() == 1 => Function::CheckPreimage(args[0].clone()),
+        "push" if args.len() == 1 => Function::Push(args[0].clone()),
+        _ => {
+            let msg = format!(
+                "Unsupported function call: {} with {} args",
+                function_name,
+                args.len()
+            );
+            return Err(ApiError::ParseScript(msg));
+        }
+    };
+
+    Ok(Expression::Function(function))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_simple_expression() {
+        let simple_script = r#"check_signature("/key", "/msg") || check_preimage("/hash")"#;
+        let expressions = parse(simple_script).expect("Failed to parse simple script");
+
+        // Should have one top-level OR expression
+        assert_eq!(expressions.len(), 1);
+
+        if let Expression::Or(left, right) = &expressions[0] {
+            // Check left side of OR
+            if let Expression::Function(Function::CheckSignature(key, msg)) = &**left {
+                match key {
+                    Key::String(key_str) => assert_eq!(*key_str, "/key"),
+                    Key::Branch(_) => panic!("Expected string key, got Branch"),
+                }
+                assert_eq!(*msg, "/msg");
+            } else {
+                panic!("Expected CheckSignature function on left side of OR");
+            }
+
+            // Check right side of OR
+            if let Expression::Function(Function::CheckPreimage(hash)) = &**right {
+                match hash {
+                    Key::String(hash_str) => assert_eq!(*hash_str, "/hash"),
+                    Key::Branch(_) => panic!("Expected string hash, got Branch"),
+                }
+            } else {
+                panic!("Expected CheckPreimage function on right side of OR");
+            }
+        } else {
+            panic!("Expected OR expression at top level");
+        }
+    }
+
+    #[test]
+    fn test_parse_with_comments() {
+        let script_str = r#"
+        // then check a possible threshold sig...
+        check_signature("/recoverykey", "/entry/") ||
+
+        // then check a possible pubkey sig...
+        check_signature("/pubkey", "/entry/") ||
+
+        // then the pre-image proof...
+        check_preimage("/hash")
+    "#;
+
+        let expressions = parse(script_str).expect("Failed to parse script with comments");
+
+        // Should have at least one expression
+        assert!(!expressions.is_empty());
+
+        // Let's collect all the function calls in order of execution
+        let mut functions = Vec::new();
+        collect_functions(&expressions[0], &mut functions);
+
+        // Verify we have exactly 3 function calls
+        assert_eq!(
+            functions.len(),
+            3,
+            "Expected 3 function calls, got {}",
+            functions.len()
+        );
+
+        // Check each function is the expected type with expected arguments
+        match &functions[0] {
+            Function::CheckSignature(key, msg) => {
+                match key {
+                    Key::String(key_str) => assert_eq!(*key_str, "/recoverykey"),
+                    Key::Branch(_) => panic!("Expected string key, got Branch"),
+                }
+                assert_eq!(*msg, "/entry/");
+            }
+            other => panic!("First function should be CheckSignature, got {:?}", other),
+        }
+
+        match &functions[1] {
+            Function::CheckSignature(key, msg) => {
+                match key {
+                    Key::String(key_str) => assert_eq!(*key_str, "/pubkey"),
+                    Key::Branch(_) => panic!("Expected string key, got Branch"),
+                }
+                assert_eq!(*msg, "/entry/");
+            }
+            other => panic!("Second function should be CheckSignature, got {:?}", other),
+        }
+
+        match &functions[2] {
+            Function::CheckPreimage(hash) => match hash {
+                Key::String(hash_str) => assert_eq!(*hash_str, "/hash"),
+                Key::Branch(_) => panic!("Expected string hash, got Branch"),
+            },
+            other => panic!("Third function should be CheckPreimage, got {:?}", other),
+        }
+    }
+
+    // Helper function to collect all Function nodes in execution order
+    fn collect_functions<'a>(expr: &'a Expression<'a>, functions: &mut Vec<Function<'a>>) {
+        match expr {
+            Expression::Function(f) => functions.push(f.clone()),
+            Expression::And(left, right) => {
+                collect_functions(left, functions);
+                collect_functions(right, functions);
+            }
+            Expression::Or(left, right) => {
+                // For OR expressions, the left side is tried first, then the right
+                collect_functions(left, functions);
+                collect_functions(right, functions);
+            }
+            Expression::Group(inner) => {
+                collect_functions(inner, functions);
+            }
+        }
+    }
+
+    #[test]
+    fn test_parse_nested_functions() {
+        let script_str = r#"check_signature(branch("pubkey"), "/entry/")"#;
+        let expressions = parse(script_str).expect("Failed to parse nested functions");
+
+        assert_eq!(expressions.len(), 1);
+
+        if let Expression::Function(Function::CheckSignature(key, msg)) = &expressions[0] {
+            match key {
+                Key::Branch(branch_str) => assert_eq!(*branch_str, "pubkey"),
+                Key::String(_) => panic!("Expected Branch key, got String"),
+            }
+            assert_eq!(*msg, "/entry/");
+        } else {
+            panic!("Expected CheckSignature with nested Branch function");
+        }
+    }
+
+    #[test]
+    fn test_parse_with_grouping() {
+        let script_str = r#"(check_eq("/value1") && check_eq("/value2"))"#;
+        let expressions = parse(script_str).expect("Failed to parse grouped expression");
+
+        assert_eq!(expressions.len(), 1);
+
+        if let Expression::Group(inner) = &expressions[0] {
+            if let Expression::And(left, right) = &**inner {
+                // Check both sides of AND
+                if let Expression::Function(Function::CheckEq(val1)) = &**left {
+                    match val1 {
+                        Key::String(val_str) => assert_eq!(*val_str, "/value1"),
+                        Key::Branch(_) => panic!("Expected String key, got Branch"),
+                    }
+                } else {
+                    panic!("Expected CheckEq on left side of AND");
+                }
+
+                if let Expression::Function(Function::CheckEq(val2)) = &**right {
+                    match val2 {
+                        Key::String(val_str) => assert_eq!(*val_str, "/value2"),
+                        Key::Branch(_) => panic!("Expected String key, got Branch"),
+                    }
+                } else {
+                    panic!("Expected CheckEq on right side of AND");
+                }
+            } else {
+                panic!("Expected AND expression inside group");
+            }
+        } else {
+            panic!("Expected Group expression at top level");
+        }
+    }
+
+    #[test]
+    fn test_parse_all_function_types() {
+        let test_script = r#"
+            check_eq("/match") && 
+            check_signature("/pubkey/path", "/message/path") && 
+            check_preimage("/hash") && 
+            push("/stack/path") 
+        "#;
+
+        let expressions = parse(test_script).expect("Failed to parse all function types");
+
+        // Should have one expression (all connected by AND operators)
+        assert_eq!(expressions.len(), 1);
+
+        // Verify the structure has all expected function types
+        // This is simplified - a complete test would traverse the full AND chain
+        let mut found_check_eq = false;
+        let mut found_check_signature = false;
+        let mut found_check_preimage = false;
+        let mut found_push = false;
+
+        // Helper function to check for function types in an expression
+        fn check_for_functions(
+            expr: &Expression,
+            check_eq: &mut bool,
+            check_sig: &mut bool,
+            check_preimage: &mut bool,
+            push: &mut bool,
+        ) {
+            match expr {
+                Expression::Function(f) => match f {
+                    Function::CheckEq(_) => *check_eq = true,
+                    Function::CheckSignature(_, _) => *check_sig = true,
+                    Function::CheckPreimage(_) => *check_preimage = true,
+                    Function::Push(_) => *push = true,
+                },
+                Expression::And(left, right) => {
+                    check_for_functions(left, check_eq, check_sig, check_preimage, push);
+                    check_for_functions(right, check_eq, check_sig, check_preimage, push);
+                }
+                Expression::Or(left, right) => {
+                    check_for_functions(left, check_eq, check_sig, check_preimage, push);
+                    check_for_functions(right, check_eq, check_sig, check_preimage, push);
+                }
+                Expression::Group(inner) => {
+                    check_for_functions(inner, check_eq, check_sig, check_preimage, push);
+                }
+            }
+        }
+
+        check_for_functions(
+            &expressions[0],
+            &mut found_check_eq,
+            &mut found_check_signature,
+            &mut found_check_preimage,
+            &mut found_push,
+        );
+
+        assert!(found_check_eq, "CheckEq function not found");
+        assert!(found_check_signature, "CheckSignature function not found");
+        assert!(found_check_preimage, "CheckPreimage function not found");
+        assert!(found_push, "Push function not found");
+    }
+
+    #[test]
+    fn test_parse_error_handling() {
+        // Wrong number of arguments
+        let invalid_script = r#"check_eq("/test", "/extra")"#;
+        assert!(
+            parse(invalid_script).is_err(),
+            "Should error with too many arguments"
+        );
+
+        // Too few arguments
+        let invalid_script = r#"check_signature("/key")"#;
+        assert!(
+            parse(invalid_script).is_err(),
+            "Should error with too few arguments"
+        );
+
+        // Unknown function
+        let invalid_script = r#"unknown_function("/test")"#;
+        assert!(
+            parse(invalid_script).is_err(),
+            "Should error with unknown function"
+        );
+    }
+
+    #[test]
+    fn test_semicolon_terminated_statements() {
+        let unlock = r#"
+        // push the serialized Entry as the message
+        push("/entry/"); 
+
+        // push the proof data
+        push("/entry/proof");
+    "#;
+
+        let expressions = parse(unlock).expect("Failed to parse script with semicolons");
+
+        // Should have two expressions
+        assert_eq!(expressions.len(), 2);
+
+        // Check the first expression is push("/entry/")
+        if let Expression::Function(Function::Push(key)) = &expressions[0] {
+            match key {
+                Key::String(path) => assert_eq!(*path, "/entry/"),
+                Key::Branch(_) => panic!("Expected string key, got Branch"),
+            }
+        } else {
+            panic!("Expected Push function for first expression");
+        }
+
+        // Check the second expression is push("/entry/proof")
+        if let Expression::Function(Function::Push(key)) = &expressions[1] {
+            match key {
+                Key::String(path) => assert_eq!(*path, "/entry/proof"),
+                Key::Branch(_) => panic!("Expected string key, got Branch"),
+            }
+        } else {
+            panic!("Expected Push function for second expression");
+        }
+    }
+}
diff --git a/crates/comrade-reference/src/context/parser/grammar.pest b/crates/comrade-reference/src/context/parser/grammar.pest
new file mode 100644
index 0000000..90f11ff
--- /dev/null
+++ b/crates/comrade-reference/src/context/parser/grammar.pest
@@ -0,0 +1,92 @@
+//! Pest grammar file for parsing Scripts into AST
+//!
+//! # Example Script to parse:
+//! ```ignore
+//! // then check a possible threshold sig...
+//! check_signature("/tpubkey", "/entry/") ||   // check_count++
+//! // then check a possible pubkey sig...
+//! check_signature("/pubkey", "/entry/") || // check_count++
+//! // then the pre-image proof...
+//! check_preimage("/hash")
+//! ```
+//!
+//! For example, the following script:
+//!
+//! ```ignore
+//! check_signature("/tpubkey", "/entry/") ||
+//! // then check a possible pubkey sig...
+//! check_signature("/pubkey", "/entry/") ||
+//! // then the pre-image proof...
+//! check_preimage("/hash")
+//! ```
+//!
+//! Would be parsed intot the AST, the executed int he same order, calling the same named functions
+//! in Rust, until "true" is returned.
+//!
+//! ## List of all possible functions:
+//! - `check_eq(key: String)`
+//! - `check_signature(key: String, msg: String)`
+//! - `check_preimage(preimage: String)`
+//! - `check_hash(hash: String)`
+//! - `push(path: String)`
+//! - `branch(branch: String) -> String`
+//!
+//! The order must be preserved such that the order of operations is the same as the order of the
+//! script.
+//!
+//! Recursion can be used as functions in the cript can be nested:
+//!
+//! ## Nested example:
+//! ```ignore
+//! // forking the parent be done by whomever can sign with "/forks/pubkey"
+//! check_signature(branch("pubkey"), "/entry/") ||
+//!
+//! // check the validity of the first entry of the child plog
+//! (check_eq(branch("vlad")) && check_signature(branch("pubkey"), "/entry/"))
+//! ````
+//! The Grammer should be pretty basic, parsing the script by line, logical operators, and
+//! comments. The script is parsed into an AST, which is then used to generate the final
+//! script.
+
+WHITESPACE = _{ " " | "\t" | "\r" }
+NEWLINE    = _{ "\n" }
+
+// Comments
+line_comment  = _{ "//" ~ (!NEWLINE ~ ANY)* }
+block_comment = _{ "/*" ~ (!"*/" ~ ANY)* ~ "*/" }
+COMMENT       = _{ line_comment | block_comment }
+
+// String literals for arguments
+string_literal = @{ "\"" ~ (!"\"" ~ ANY)* ~ "\"" | "'" ~ (!("'" | NEWLINE) ~ ANY)* ~ "'" }
+
+// Path literals (strings starting with "/")
+path_literal = @{ "\"" ~ "/" ~ (!"\"" ~ ANY)* ~ "\"" | "'" ~ "/" ~ (!("'" | NEWLINE) ~ ANY)* ~ "'" }
+
+// Identifiers for function names and non-quoted arguments
+identifier = @{ ASCII_ALPHA ~ (ASCII_ALPHANUMERIC | "_")* }
+
+// Arguments can be string literals, path literals, identifiers, or function calls
+argument = _{ function_call | string_literal | path_literal | identifier }
+
+// Forward declaration for function_call to allow recursion
+function_call = { identifier ~ "(" ~ (argument ~ ("," ~ argument)*)? ~ ")" }
+
+// Expression can be a function call or a parenthesized expression
+primary_expr = { function_call | "(" ~ expr ~ ")" }
+
+// Logical operators with precedence
+or_expr = {
+    and_expr ~ (NEWLINE* ~ "||" ~ NEWLINE* ~ and_expr)*
+}
+
+and_expr = {
+    primary_expr ~ (NEWLINE* ~ "&&" ~ NEWLINE* ~ primary_expr)*
+}
+
+// Top-level expression
+expr = { or_expr }
+
+// A script is a series of expressions separated by optional newlines and optional semicolons
+script = {
+    SOI ~ NEWLINE* ~ (expr ~ (";" ~ NEWLINE* ~ expr)* ~ ";"?)? ~ NEWLINE* ~ EOI
+}
diff --git a/crates/comrade-reference/src/context/stack.rs b/crates/comrade-reference/src/context/stack.rs
new file mode 100644
index 0000000..5554c7a
--- /dev/null
+++ b/crates/comrade-reference/src/context/stack.rs
@@ -0,0 +1,62 @@
+use crate::Value;
+
+/// Trait for a value stack
+pub trait Stack {
+    /// push a value onto the stack
+    fn push(&mut self, value: Value);
+
+    /// remove the last top value from the stack
+    fn pop(&mut self) -> Option<Value>;
+
+    /// get a reference to the top value on the stack
+    fn top(&self) -> Option<Value>;
+
+    /// peek at the item at the given index
+    fn peek(&self, idx: usize) -> Option<Value>;
+
+    /// return the number of values on the stack
+    fn len(&self) -> usize;
+
+    /// return if the stack is empty
+    fn is_empty(&self) -> bool;
+}
+
+#[derive(Default, Clone, Debug)]
+pub struct Stk {
+    pub stack: Vec<Value>,
+}
+
+impl Stack for Stk {
+    /// push a value onto the stack
+    fn push(&mut self, value: Value) {
+        self.stack.push(value);
+    }
+
+    /// remove the last top value from the stack
+    fn pop(&mut self) -> Option<Value> {
+        self.stack.pop()
+    }
+
+    /// get a reference to the top value on the stack
+    fn top(&self) -> Option<Value> {
+        self.stack.last().cloned()
+    }
+
+    /// peek at the item at the given index
+    fn peek(&self, idx: usize) -> Option<Value> {
+        if idx >= self.stack.len() {
+            return None;
+        }
+        Some(self.stack[self.stack.len() - 1 - idx].clone())
+    }
+
+    /// return the number of values on the stack
+    fn len(&self) -> usize {
+        self.stack.len()
+    }
+
+    /// return if the stack is empty
+    fn is_empty(&self) -> bool {
+        self.stack.is_empty()
+    }
+}
diff --git a/crates/comrade-reference/src/context/value.rs b/crates/comrade-reference/src/context/value.rs
new file mode 100644
index 0000000..794af24
--- /dev/null
+++ b/crates/comrade-reference/src/context/value.rs
@@ -0,0 +1,58 @@
+/// The values that can be pushed onto the stack
+#[derive(Clone, PartialEq, Debug)]
+pub enum Value {
+    /// A binary blob value with debugging hint
+    Bin {
+        /// Arbitrary description of the data for debugging purposes
+        hint: String,
+        /// Binary value data
+        data: Vec<u8>,
+    },
+    /// A printable string value with debugging hint
+    Str {
+        /// Arbitrary description of the data for debugging purposes
+        hint: String,
+        /// String value data
+        data: String,
+    },
+    /// Sucess marker
+    Success(usize),
+    /// Failure marker
+    Failure(String),
+}
+
+impl From<&[u8]> for Value {
+    fn from(b: &[u8]) -> Self {
+        Value::from(b.to_vec())
+    }
+}
+
+impl From<Vec<u8>> for Value {
+    fn from(b: Vec<u8>) -> Self {
+        Value::Bin {
+            hint: "".to_string(),
+            data: b,
+        }
+    }
+}
+
+impl From<&str> for Value {
+    fn from(s: &str) -> Self {
+        Value::from(s.to_string())
+    }
+}
+
+impl From<String> for Value {
+    fn from(s: String) -> Self {
+        Value::Str {
+            hint: "".to_string(),
+            data: s,
+        }
+    }
+}
+
+impl From<usize> for Value {
+    fn from(n: usize) -> Self {
+        Value::Success(n)
+    }
+}
diff --git a/crates/comrade-reference/src/error.rs b/crates/comrade-reference/src/error.rs
new file mode 100644
index 0000000..878ec3f
--- /dev/null
+++ b/crates/comrade-reference/src/error.rs
@@ -0,0 +1,14 @@
+//! Crate level error handling.
+
+use crate::context::Rule;
+
+#[derive(Debug, thiserror::Error)]
+pub enum ApiError {
+    /// Error parsing the Script
+    #[error("Error parsing the Script: {0}")]
+    ParseScript(String),
+
+    /// expected `std::boxed::Box<pest::error::Error<pest::Rule>>`, found `pest::error::Error<pest::Rule>`
+    #[error("Error parsing the Script: {0}")]
+    PestParse(#[from] Box<pest::error::Error<Rule>>),
+}
diff --git a/crates/comrade-reference/src/lib.rs b/crates/comrade-reference/src/lib.rs
new file mode 100644
index 0000000..d13da9b
--- /dev/null
+++ b/crates/comrade-reference/src/lib.rs
@@ -0,0 +1,12 @@
+// Include readme at header, with rustdoc tests
+#![doc = include_str!("../README.md")]
+pub struct ReadmeDocumentation;
+
+/// Crate level errors
+mod error;
+pub use error::ApiError;
+
+/// Context is the main entry of this crate
+mod context;
+/// Public re-exports
+pub use context::{Context, Log, Pairs, Stack, Value};
diff --git a/crates/comrade/Cargo.toml b/crates/comrade/Cargo.toml
new file mode 100644
index 0000000..5c61422
--- /dev/null
+++ b/crates/comrade/Cargo.toml
@@ -0,0 +1,41 @@
+[package]
+name = "comrade"
+version.workspace = true
+edition.workspace = true
+authors.workspace = true
+description.workspace = true
+readme.workspace = true
+license.workspace = true
+
+[dependencies]
+comrade-reference.workspace = true
+thiserror = "2.0"
+# wasm_component_layer gives us an isomorphic way to load components
+# in native or the browser directly from Rust
+# patch until this lands: https://github.com/DouglasDwyer/wasm_component_layer/pull/26
+wasm_component_layer = { git = "https://github.com/DougAnderson444/wasm_component_layer.git", branch = "dep-fix", optional = true }
+tracing = { version = "0.1", features = ["log"] }
+tracing-subscriber = { version = "0.3", features = ["std"] }
+getrandom = "0.3"
+anyhow = "1.0"
+
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+wasmi_runtime_layer = "=0.40.0" # pin to 0.40 to match wasm_runtime_layer 0.4.2
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+js_wasm_runtime_layer = { version = "0.4.0", features = ["tracing"] }
+wasm-bindgen = "0.2"
+getrandom = { version = "0.3", features = ["wasm_js"] }
+# We have netsed deps that use v0.2, so we need to ensure the feature is flagged here
+getrandom_v02 = { package = "getrandom", version = "0.2.15", features = ["js"] }
+web-sys = { version = "0.3", features = ["Window", "Crypto"] }
+hex = "0.4"
+console_error_panic_hook = "0.1"
+tracing-wasm = "0.2"                                                             # For sending tracing events to browser console
+
+[dev-dependencies]
+wasm-bindgen-test = "0.3"
+hex = "0.4"
+
+[lints]
+workspace = true
diff --git a/crates/comrade/README.md b/crates/comrade/README.md
new file mode 100644
index 0000000..e26e417
--- /dev/null
+++ b/crates/comrade/README.md
@@ -0,0 +1,173 @@
+# Comrade
+
+A flexible, extensible, and composable way to run provenance log scripts natively or in the browser.
+
+- Flexible: Because we use plain text scripts, they can be run by any Scritp runtime imaginable.
+- Extensible: The Comrade library is designed to be extensible, allowing users to add their own custom script runtimes and components.
+- Composable: Designed to be able to mix and match runtimes through the same interface.
+
+## Overview
+
+This crate is the main entry point for the Comrade crate libraries, which provides a framework for executing provenance log scripts in both native and browser environments. Comrade enables flexible script execution with support for lock and unlock operations through an intuitive key-value pair interface.
+
+This crate is run during the "Verification" step of using a provenance log.
+
+## Features
+
+- Execute text-based provenance log scripts in native Rust or browser environments
+- Flexible key-value pair interface for script data management
+- Support for lock and unlock script operations
+- Wasm component model compatibility
+
+## Installation
+
+This crate is designed to be used in the [../provenance-log/Cargo.toml](../provenance-log/) crate by adding this to the `Cargo.toml`:
+
+```toml
+[dependencies]
+comrade.workspace = true
+```
+
+## Use 
+
+The main API aims to be as simple as possible, and the following example shows how to use the Comrade library to run a script:
+
+```rust
+use comrade::Comrade;
+use comrade_reference::{Pairs, Value};
+use std::collections::HashMap;
+
+#[derive(Clone, Default, Debug)]
+struct TestData(HashMap<String, Value>);
+
+impl Pairs for TestData {
+    fn get(&self, key: &str) -> Option<Value> {
+        self.0.get(key).cloned()
+    }
+
+    fn put(&mut self, key: &str, value: &Value) -> Option<Value> {
+        self.0.insert(key.to_string(), value.clone())
+    }
+}
+
+// The message to sign, in both the lock and unlock scripts
+let entry_key = "/entry/";
+let entry_data = b"for great justice, move every zig!";
+
+// The proof data that is provided by the unlock script
+let proof_key = "/entry/proof";
+let proof_data = hex::decode("b92483a6c006000100404819397f51b18bc6cffd1fff07afa33f7096c7a0c659590b077cc0ea5d6081d739512129becacb8e6997e6b7d18756299f515a822344ac2b6737979d5e5e6b03").unwrap();
+
+// The public key to that must be proven by unlock scripts
+let pubkey = "/pubkey";
+let pub_key = hex::decode("ba24ed010874657374206b657901012054d94d7b8a11d6581af4a14bc6451c7a23049018610f108c996968fe8fce9464").unwrap();
+
+// Our Key-Value Pairs
+let mut kvp_unlock = TestData::default();
+let mut kvp_lock = TestData::default();
+
+// "/entry/" needs to be present on both lock and unlock stacks,
+// since they are used in both the unlock and lock scripts:
+// ie. push("/entry/") and check_signature("/pubkey", "/entry/")
+kvp_unlock.put(entry_key, &entry_data.to_vec().into());
+kvp_lock.put(entry_key, &entry_data.to_vec().into());
+
+// "/entry/proof" only needs to be present on the unlock stack,
+// since that's where the proof is used
+kvp_unlock.put(proof_key, &proof_data.clone().into());
+
+// "/pubkey" needs to be present on lock stack, to set what the PubKey is
+kvp_lock.put(pubkey, &pub_key.into());
+
+let unlock_script = format!(
+    r#"
+        // push the serialized Entry as the message
+        push("{entry_key}"); 
+
+        // push the proof data
+        push("{proof_key}");
+    "#
+);
+
+let first_lock = format!(
+    r#"
+        // check the first key, which is ephemeral
+        check_signature("/ephemeral", "{entry_key}") 
+    "#
+);
+
+let other_lock_script = format!(
+    r#"
+        // then check a possible threshold sig...
+        check_signature("/recoverykey", "{entry_key}") ||
+
+        // then check a possible pubkey sig...
+        check_signature("/pubkey", "{entry_key}") ||
+        
+        // then the pre-image proof...
+        check_preimage("/hash")
+    "#
+);
+
+let mut comrade = Comrade::new(&kvp_lock, &kvp_unlock)
+    .try_unlock(&unlock_script)
+    .expect("Failed to unlock comrade");
+
+// check the lock scripts
+let locks = [first_lock, other_lock_script];
+
+// check the locks
+let mut count = 0;
+for lock in locks {
+    if let Some(Value::Success(ct)) =
+        comrade.try_lock(&lock).expect("Failed to lock comrade")
+    {
+        count = ct;
+        break;
+    }
+}
+
+// check the count
+assert_eq!(count, 2);
+```
+
+## Tests 
+
+To run the tests:
+
+```sh 
+# see http://just.systems/ for more details
+just test
+```
+
+This will ensure the default component is built and available for the default wasm runtime.
+
+## Architecture
+
+Comrade is designed with a modular architecture that consists of:
+
+1. **Core API**: The main `Comrade` struct provides a simple interface for script execution
+2. **Reference Implementation**: The crate includes a reference [runtime](./src/runtime) implementation with default behaviors
+3. **WASM Integration**: Support for WebAssembly [components](./src/runtime/layer/mod.rs) enables cross-language, composability possibilities
+
+By default, Comrade uses a direct implementation in Rust. But, it is possible to break up the build into modular wasm components and compose them together. This is being left as an area for future work when demand arises.
+
+### Wasm Component Layer
+
+This reference implementation makes opinions about what dependencies to use and which runtime to use to run the components, but it should be noted that it is possible to swap in your own runtime for both the component and the wasm runtime. 
+
+For example, `wasm_component_layer` crate gives us an isomorphic way to load components in native or the browser directly from Rust. We use a patch until [this dependency fix lands](https://github.com/DouglasDwyer/wasm_component_layer/pull/26). 
+
+## Related Crates
+
+- `comrade_reference`: Provides the reference implementation for Comrade, which can be used directly in Comrade, or bundled into a wasm component.
+- `wasmi_runtime`: Native runtime for WebAssembly components
+- `js_wasm_runtime_layer`: Browser runtime for WebAssembly components
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+FSL-1.1
diff --git a/crates/comrade/justfile b/crates/comrade/justfile
new file mode 100644
index 0000000..02a936c
--- /dev/null
+++ b/crates/comrade/justfile
@@ -0,0 +1,15 @@
+build-component:
+  # Run Cargo Component Build first 
+  just -f ../../justfile build
+
+# To call headless 
+# just test-wasm32 --headless
+test-wasm32 *args:
+  # wasm32 test for the browser
+  RUSTFLAGS='--cfg getrandom_backend="wasm_js"' wasm-pack test --chrome {{args}} --all-features 
+
+test: 
+  just test-wasm32 --headless
+  cargo test
+
+
diff --git a/crates/comrade/src/error.rs b/crates/comrade/src/error.rs
new file mode 100644
index 0000000..7203369
--- /dev/null
+++ b/crates/comrade/src/error.rs
@@ -0,0 +1,24 @@
+//! Crate errors
+
+/// Comrade error types
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+    #[error("Invalid argument: {0}")]
+    WasmFnCall(#[from] anyhow::Error),
+    /// Error in the  Script
+    #[error("Script has failed to run, yuo likely have an error in your script: {0}")]
+    ScriptFailure(String),
+
+    /// APiError
+    #[error(transparent)]
+    ApiError(#[from] comrade_reference::ApiError),
+    // /// Error in the VM
+    // #[error("VM error: {0}")]
+    // Vm(#[from] wasmi::Error),
+    // /// Error in the component
+    // #[error("Component error: {0}")]
+    // Component(#[from] comrade_reference::Error),
+    // /// Error in the script
+    // #[error("Script error: {0}")]
+    // Script(#[from] comrade_reference::ScriptError),
+}
diff --git a/crates/comrade/src/lib.rs b/crates/comrade/src/lib.rs
new file mode 100644
index 0000000..4c18bc6
--- /dev/null
+++ b/crates/comrade/src/lib.rs
@@ -0,0 +1,294 @@
+//! Comrade is an execution engine for provenance log scripts.
+//!
+//! It requires a Script Runtime to run. A reference implementation is
+//! provided in the [crate::runtime::Runner] module which uses [comrade_reference]
+//! directly in Rust. In the future, this crate *can* support other runtimes,
+//! such as [wasm_component_layer] based wasm components.
+//!
+//! The Comrade API should look something like:
+//!
+//! ```ignore
+//! let unlocked = Comrade::new(kvp_lock, kvp_unlock)
+//!     .with_domain("/")
+//!     .try_unlock(&unlock)?;
+//!
+//! let mut count = 0;
+//!
+//! for lock in locks {
+//!     if let Some(Value::Success(ct)) = unlocked.try_lock(lock)? {
+//!         count = ct;
+//!         break;
+//!     }
+//! }
+//! ````
+//!
+//! where the args iml [comrade_reference::Pairs]
+
+// Include readme at header, with rustdoc tests
+#![doc = include_str!("../README.md")]
+pub struct ReadmeDocumentation;
+
+mod error;
+pub use crate::error::Error;
+
+/// The runtime environment for the scripts
+mod runtime;
+
+/// Polyfills required to ensure getrandom v0.3 works in wasm32 targets
+#[cfg(target_arch = "wasm32")]
+mod random;
+
+// Using the same trait out of convenience, the Pairs trait is very basic
+pub use comrade_reference::{Pairs, Value};
+use runtime::Runtime as _;
+
+/// Comrade goes starts at [Initial] Stage, then goes to [Unlocked] Stage.
+#[derive(Debug)]
+pub struct Initial;
+
+/// Comrade goes starts at [Initial] Stage, then goes to [Unlocked] Stage.
+#[derive(Debug)]
+pub struct Unlocked;
+
+/// Opinionated entry API for using Comrade.
+/// Uses the comrade-component reference implementation by default,
+/// and wasm_component_layer for runtime. Either can be substituted
+/// with prefered alternatives as desired.
+pub struct Comrade<'un, 'lo, Stage = Initial> {
+    // /// The key-value pairs asociated with the lock
+    // kvp_lock: C,
+    // /// The key-value pairs asociated with the unlock
+    // kvp_unlock: P,
+    runner: runtime::Runner<'un, 'lo>,
+    _stage: std::marker::PhantomData<Stage>,
+}
+
+impl<'un, 'lo> Comrade<'un, 'lo> {
+    /// Creates a new Comrade instance with the given lock and unlock pairs.
+    pub fn new(kvp_lock: &'un impl Pairs, kvp_unlock: &'lo impl Pairs) -> Self {
+        Comrade {
+            runner: runtime::Runner::new(kvp_lock, kvp_unlock),
+            _stage: std::marker::PhantomData,
+        }
+    }
+
+    /// Optionally set the key-path domain for use in branch() functions.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # use std::error::Error;
+    /// # use comrade::{Comrade, Value};
+    /// #
+    /// # // Mock implementation for doctests
+    /// # struct MockPairs;
+    /// # impl comrade::Pairs for MockPairs {
+    /// #     fn get(&self, _: &str) -> Option<Value> { None }
+    /// #     fn put(&mut self, _: &str, _: &Value) -> Option<Value> { None }
+    /// # }
+    /// #
+    /// # fn main() -> Result<(), Box<dyn Error>> {
+    /// let kvp_lock = MockPairs;
+    /// let kvp_unlock = MockPairs;
+    /// let unlock = r#"push("/entry_key/"); push("/entry_key/proof");"#;
+    /// let unlocked = Comrade::new(&kvp_lock, &kvp_unlock)
+    ///     .with_domain("/forks/child")
+    ///     .try_unlock(unlock)?;
+    ///
+    /// // full path is now "/forks/child/entry_key/" and "/forks/child/entry_key/proof"
+    /// #
+    /// # Ok(())
+    /// # }
+    pub fn with_domain(mut self, domain: &str) -> Self {
+        self.runner.with_domain(domain);
+        self
+    }
+
+    /// Tries to unlock the comrade with the given script.
+    /// Will return an error if the script fails to run.
+    pub fn try_unlock(mut self, script: &'un str) -> Result<Comrade<'un, 'lo, Unlocked>, Error> {
+        self.runner.try_unlock(script)?;
+        Ok(self.into())
+    }
+}
+
+// try_lock can only be called on an Unlocked Comrade
+impl Comrade<'_, '_, Unlocked> {
+    /// Tries to lock the comrade with the given script.
+    /// Will return an error if the script fails to run.
+    pub fn try_lock(&mut self, script: &str) -> Result<Option<Value>, Error> {
+        let res = self.runner.try_lock(script)?;
+        Ok(res)
+    }
+}
+
+// from Initial to Unlocked
+impl<'un, 'lo> From<Comrade<'un, 'lo, Initial>> for Comrade<'un, 'lo, Unlocked> {
+    fn from(comrade: Comrade<'un, 'lo>) -> Self {
+        Comrade {
+            // kvp_lock: comrade.kvp_lock,
+            // kvp_unlock: comrade.kvp_unlock,
+            runner: comrade.runner,
+            _stage: std::marker::PhantomData,
+        }
+    }
+}
+
+#[cfg(any(target_arch = "wasm32", test))]
+pub mod tests {
+    use super::*;
+    use comrade_reference::Pairs;
+    use std::collections::HashMap;
+
+    #[derive(Clone, Default, Debug)]
+    pub struct TestData(HashMap<String, Value>);
+
+    impl Pairs for TestData {
+        fn get(&self, key: &str) -> Option<Value> {
+            self.0.get(key).cloned()
+        }
+
+        fn put(&mut self, key: &str, value: &Value) -> Option<Value> {
+            self.0.insert(key.to_string(), value.clone())
+        }
+    }
+
+    // Helper functions that set up test data
+    pub mod helpers {
+        use super::*;
+
+        // Autotrait test
+        // Comrade is not Send or Sync, but it is Unpin
+        // pub(crate) fn is_normal<T: Sized + Send + Sync + Unpin>() {}
+        pub(crate) fn is_sized_unnpin<T: Sized + Unpin>() {}
+
+        pub fn unlock_script(entry_key: &str, proof_key: &str) -> String {
+            format!(
+                r#"
+                // push the serialized Entry as the message
+                push("{entry_key}"); 
+
+                // push the proof data
+                push("{proof_key}");
+            "#
+            )
+        }
+
+        pub fn first_lock_script(entry_key: &str) -> String {
+            format!(
+                r#"
+                // check the first key, which is ephemeral
+                check_signature("/ephemeral", "{entry_key}") 
+            "#
+            )
+        }
+
+        pub fn other_lock_script(entry_key: &str) -> String {
+            format!(
+                r#"
+                // then check a possible threshold sig...
+                check_signature("/recoverykey", "{entry_key}") ||
+
+                // then check a possible pubkey sig...
+                check_signature("/pubkey", "{entry_key}") ||
+                
+                // then the pre-image proof...
+                check_preimage("/hash")
+            "#
+            )
+        }
+
+        pub fn proof_data() -> Vec<u8> {
+            hex::decode("b92483a6c006000100404819397f51b18bc6cffd1fff07afa33f7096c7a0c659590b077cc0ea5d6081d739512129becacb8e6997e6b7d18756299f515a822344ac2b6737979d5e5e6b03").unwrap()
+        }
+
+        pub fn pub_key() -> Vec<u8> {
+            hex::decode("ba24ed010874657374206b657901012054d94d7b8a11d6581af4a14bc6451c7a23049018610f108c996968fe8fce9464").unwrap()
+        }
+
+        // Creates a setup with all necessary key-value pairs
+        pub fn setup_test_data() -> (TestData, TestData, String) {
+            // The message to sign, in both the lock and unlock scripts
+            let entry_key = "/entry/";
+            let entry_data = b"for great justice, move every zig!";
+
+            // The proof data that is provided by the unlock script
+            let proof_key = "/entry/proof";
+            let proof_data = proof_data();
+
+            // The public key to that must be proven by unlock scripts
+            let pubkey = "/pubkey";
+            let pub_key = pub_key();
+
+            // Our Key-Value Pairs
+            let mut kvp_unlock = TestData::default();
+            let mut kvp_lock = TestData::default();
+
+            // Set up the key-value pairs
+            kvp_unlock.put(entry_key, &entry_data.to_vec().into());
+            kvp_lock.put(entry_key, &entry_data.to_vec().into());
+            kvp_unlock.put(proof_key, &proof_data.clone().into());
+            kvp_lock.put(pubkey, &pub_key.into());
+
+            // Return the configured test data and entry key
+            (kvp_lock, kvp_unlock, entry_key.to_string())
+        }
+    }
+
+    // The main test function that both native tests and WASM tests will call
+    pub fn test_comrade_api() {
+        use helpers::*;
+
+        // Get our test setup
+        let (kvp_lock, kvp_unlock, entry_key) = setup_test_data();
+        let proof_key = "/entry/proof";
+
+        // Create the scripts
+        let unlock_script = unlock_script(&entry_key, proof_key);
+        let first_lock = first_lock_script(&entry_key);
+        let other_lock_script = other_lock_script(&entry_key);
+
+        let mut comrade = Comrade::new(&kvp_lock, &kvp_unlock)
+            .try_unlock(&unlock_script)
+            .expect("Failed to unlock comrade");
+
+        // check the lock scripts
+        let locks = [first_lock, other_lock_script];
+
+        // check the locks
+        let mut count = 0;
+        for lock in locks {
+            if let Some(Value::Success(ct)) =
+                comrade.try_lock(&lock).expect("Failed to lock comrade")
+            {
+                count = ct;
+                break;
+            }
+        }
+
+        // check the count
+        assert_eq!(count, 2);
+    }
+
+    // Autotrait test for non-wasm32 targets
+    #[test]
+    #[cfg(not(target_arch = "wasm32"))]
+    fn test_autotraits() {
+        // This is a dummy test to ensure that the crate runs in wasm32 target
+        // and that the autotrait implementation is what is expected.
+        helpers::is_sized_unnpin::<Comrade<'_, '_>>();
+    }
+
+    // This is the actual test that cargo test will run
+    #[test]
+    pub fn test_comrade_public_api() {
+        test_comrade_api();
+    }
+}
+
+#[cfg(target_arch = "wasm32")]
+pub mod wasm_tests {
+    pub fn run() {
+        super::tests::test_comrade_api();
+    }
+}
diff --git a/crates/comrade/src/random.rs b/crates/comrade/src/random.rs
new file mode 100644
index 0000000..5cc0d37
--- /dev/null
+++ b/crates/comrade/src/random.rs
@@ -0,0 +1,34 @@
+//! Implements random for this wasm32-unknown-unknown target.
+//!
+//! Since we was wasm but ARE NOT int he browser, we need to use the
+//! custom function to generate random bytes.
+//!
+//! However, since getrandom v0.2 and v0.3 are both present in dependencies,
+//! and have different APIs, we need to implement both of them.
+#![cfg(target_arch = "wasm32")]
+use wasm_bindgen::prelude::*;
+use web_sys::window;
+
+/// Browser getrandom v0.3 requires RUSTFLAGS='--cfg getrandom_backend="wasm_js"'  
+/// and this function.
+///
+/// # Safety
+/// This function is unsafe because it dereferences raw pointers.
+#[unsafe(no_mangle)]
+pub unsafe extern "Rust" fn __getrandom_v03_custom(
+    dest: *mut u8,
+    len: usize,
+) -> Result<(), getrandom::Error> {
+    // Safety: This is safe because we are using the imported_random function
+    // which is safe to use in this context.
+    let slice = unsafe { std::slice::from_raw_parts_mut(dest, len) };
+    bindgen_byte(slice).map_err(|_| getrandom::Error::UNSUPPORTED)?;
+    Ok(())
+}
+
+fn bindgen_byte(buffer: &mut [u8]) -> Result<(), JsValue> {
+    let window = window().ok_or_else(|| JsValue::from_str("window not available"))?;
+    let crypto = window.crypto()?;
+    crypto.get_random_values_with_u8_array(buffer)?;
+    Ok(())
+}
diff --git a/crates/comrade/src/runtime/direct/logs.rs b/crates/comrade/src/runtime/direct/logs.rs
new file mode 100644
index 0000000..dbac984
--- /dev/null
+++ b/crates/comrade/src/runtime/direct/logs.rs
@@ -0,0 +1,9 @@
+use comrade_reference::Log;
+
+pub(crate) struct Logger;
+
+impl Log for Logger {
+    fn log(&self, msg: &str) {
+        tracing::info!("{}", msg);
+    }
+}
diff --git a/crates/comrade/src/runtime/direct/mod.rs b/crates/comrade/src/runtime/direct/mod.rs
new file mode 100644
index 0000000..70a799e
--- /dev/null
+++ b/crates/comrade/src/runtime/direct/mod.rs
@@ -0,0 +1,36 @@
+//! Use the comrrade-reference implementation of the runtime as a direct dependency.
+mod logs;
+
+use super::Runtime;
+use comrade_reference::{Context, Pairs, Value};
+
+/// The "Direct" runtime uses the comrade-reference implementation directly in rust
+/// and is the default runtime for Comrade.
+pub(crate) struct Runner<'un, 'lo> {
+    pub(crate) context: Context<'un, 'lo>,
+}
+
+impl<'un, 'lo> Runner<'un, 'lo> {
+    /// Creates a new Runner instance with the given lock and unlock pairs.
+    pub fn new(kvp_lock: &'un impl Pairs, kvp_unlock: &'lo impl Pairs) -> Self {
+        Self {
+            context: Context::new(kvp_lock, kvp_unlock, &logs::Logger),
+        }
+    }
+}
+
+impl Runtime for Runner<'_, '_> {
+    fn with_domain(&mut self, domain: &str) {
+        self.context.domain = domain.to_string();
+    }
+
+    fn try_unlock(&mut self, script: &str) -> Result<(), crate::Error> {
+        self.context.run(script)?;
+        Ok(())
+    }
+
+    fn try_lock(&mut self, script: &str) -> Result<Option<Value>, crate::Error> {
+        self.context.run(script)?;
+        Ok(self.context.rstack())
+    }
+}
diff --git a/crates/comrade/src/runtime/layer/definitions.rs b/crates/comrade/src/runtime/layer/definitions.rs
new file mode 100644
index 0000000..1837b59
--- /dev/null
+++ b/crates/comrade/src/runtime/layer/definitions.rs
@@ -0,0 +1,257 @@
+use crate::Pairs;
+use std::collections::HashMap;
+use wasm_component_layer::*;
+
+pub fn list_data() -> ValueType {
+    ValueType::List(ListType::new(ValueType::U8))
+}
+
+pub fn binary_rec_ty() -> RecordType {
+    RecordType::new(
+        None,
+        vec![("data", list_data()), ("hint", ValueType::String)],
+    )
+    .unwrap()
+}
+
+pub fn str_rec_ty() -> RecordType {
+    RecordType::new(
+        None,
+        vec![("data", ValueType::String), ("hint", ValueType::String)],
+    )
+    .unwrap()
+}
+
+/// Vlaue variant type is either, binary, str, success(u32), or failure(String)
+pub fn value_variant() -> VariantType {
+    VariantType::new(
+        None,
+        vec![
+            VariantCase::new("bin", Some(ValueType::Record(binary_rec_ty()))),
+            VariantCase::new("str", Some(ValueType::Record(str_rec_ty()))),
+            VariantCase::new("success", Some(ValueType::U32)),
+            VariantCase::new("failure", Some(ValueType::String)),
+        ],
+    )
+    .unwrap()
+}
+
+/// Represents either: a current or proposed
+pub fn either_enum() -> EnumType {
+    EnumType::new(None, vec!["current", "proposed"]).unwrap()
+}
+
+pub fn bin_variant(data: Vec<u8>, hint: String) -> Value {
+    Value::Variant(
+        Variant::new(
+            value_variant(),
+            0,
+            Some(Value::Record(
+                Record::new(
+                    binary_rec_ty(),
+                    vec![
+                        (
+                            "data",
+                            Value::List(
+                                List::new(
+                                    ListType::new(ValueType::U8),
+                                    data.iter().map(|b| Value::U8(*b)).collect::<Vec<Value>>(),
+                                )
+                                .unwrap(),
+                            ),
+                        ),
+                        ("hint", Value::String(hint.into())),
+                    ],
+                )
+                .unwrap(),
+            )),
+        )
+        .unwrap(),
+    )
+}
+
+pub fn str_variant(data: String, hint: String) -> Value {
+    Value::Variant(
+        Variant::new(
+            value_variant(),
+            1,
+            Some(Value::Record(
+                Record::new(
+                    str_rec_ty(),
+                    vec![
+                        ("data", Value::String(data.into())),
+                        ("hint", Value::String(hint.into())),
+                    ],
+                )
+                .unwrap(),
+            )),
+        )
+        .unwrap(),
+    )
+}
+
+pub fn failure_variant(msg: String) -> Value {
+    Value::Variant(Variant::new(value_variant(), 3, Some(Value::String(msg.into()))).unwrap())
+}
+
+/// Success variant
+pub fn success_variant(code: u32) -> Value {
+    Value::Variant(Variant::new(value_variant(), 2, Some(Value::U32(code))).unwrap())
+}
+
+#[derive(Clone, Default, Debug)]
+pub struct ContextPairs {
+    pairs: HashMap<String, crate::Value>,
+}
+
+impl Pairs for ContextPairs {
+    fn get(&self, key: &str) -> Option<crate::Value> {
+        self.pairs.get(key).cloned()
+    }
+
+    fn put(&mut self, key: &str, value: &crate::Value) -> Option<crate::Value> {
+        self.pairs.insert(key.to_string(), value.clone())
+    }
+}
+
+/// From crate::Value to wasm_component_layer::Value
+pub fn into_comp_value(value: crate::Value) -> Result<wasm_component_layer::Value, String> {
+    match value {
+        crate::Value::Bin { hint, data } => {
+            // Create the record first
+            let record = Record::new(
+                binary_rec_ty(),
+                vec![
+                    (
+                        "data",
+                        Value::List(
+                            List::new(
+                                ListType::new(ValueType::U8),
+                                data.iter().map(|b| Value::U8(*b)).collect::<Vec<Value>>(),
+                            )
+                            .unwrap(),
+                        ),
+                    ),
+                    ("hint", Value::String(hint.into())),
+                ],
+            )
+            .unwrap();
+
+            // Then wrap it in the variant (bin is case 0)
+            Ok(Value::Variant(
+                Variant::new(value_variant(), 0, Some(Value::Record(record))).unwrap(),
+            ))
+        }
+        crate::Value::Str { hint, data } => {
+            // Create the record first
+            let record = Record::new(
+                str_rec_ty(),
+                vec![
+                    ("data", Value::String(data.into())),
+                    ("hint", Value::String(hint.into())),
+                ],
+            )
+            .unwrap();
+
+            // Then wrap it in the variant (str is case 1)
+            Ok(Value::Variant(
+                Variant::new(value_variant(), 1, Some(Value::Record(record))).unwrap(),
+            ))
+        }
+        _ => Err(format!(
+            "Cannot convert {:?} to wasm_component_layer::Value",
+            value
+        )),
+    }
+}
+
+/// Convert from [wasm_component_layer::Value] to [crate::Value]
+pub fn into_core_value(value: wasm_component_layer::Value) -> Result<crate::Value, String> {
+    match value {
+        wasm_component_layer::Value::Option(option_value) => match *option_value {
+            Some(ref value) => into_core_value(value.clone()),
+            None => Ok(crate::Value::Failure("Option value is None".to_string())),
+        },
+        wasm_component_layer::Value::Variant(variant) => {
+            match variant.discriminant() {
+                0 => {
+                    // bin
+                    if let Some(Value::Record(record)) = variant.value() {
+                        if let Some(Value::String(hint)) = record.field("hint") {
+                            if let Some(Value::List(list)) = record.field("data") {
+                                let data: Vec<u8> = list
+                                    .iter()
+                                    .map(|v| match v {
+                                        Value::U8(b) => Ok(b),
+                                        _ => Err(format!("Expected U8, found {:?}", v)),
+                                    })
+                                    .collect::<Result<Vec<u8>, String>>()?;
+                                return Ok(crate::Value::Bin {
+                                    hint: hint.to_string(),
+                                    data,
+                                });
+                            }
+                        }
+                    }
+                    Err(format!("Invalid bin variant: {:?}", variant))
+                }
+                1 => {
+                    // str
+                    if let Some(Value::Record(record)) = variant.value() {
+                        if let Some(Value::String(hint)) = record.field("hint") {
+                            if let Some(Value::String(data)) = record.field("data") {
+                                return Ok(crate::Value::Str {
+                                    hint: hint.to_string(),
+                                    data: data.to_string(),
+                                });
+                            }
+                        }
+                    }
+                    Err(format!("Invalid str variant: {:?}", variant))
+                }
+                2 => {
+                    // success
+                    if let Some(Value::U32(code)) = variant.value() {
+                        return Ok(crate::Value::Success(code as usize));
+                    }
+                    Err(format!("Invalid success variant: {:?}", variant))
+                }
+                3 => {
+                    // failure
+                    if let Some(Value::String(msg)) = variant.value() {
+                        return Ok(crate::Value::Failure(msg.to_string()));
+                    }
+                    Err(format!("Invalid failure variant: {:?}", variant))
+                }
+                _ => Err(format!(
+                    "Unknown variant discriminant: {}",
+                    variant.discriminant()
+                )),
+            }
+        }
+        wasm_component_layer::Value::Record(record) => {
+            if let Some(Value::String(hint)) = record.field("hint") {
+                if let Some(Value::List(list)) = record.field("data") {
+                    let data: Vec<u8> = list
+                        .iter()
+                        .map(|v| match v {
+                            Value::U8(b) => Ok(b),
+                            _ => Err(format!("Expected U8, found {:?}", v)),
+                        })
+                        .collect::<Result<Vec<u8>, String>>()?;
+                    return Ok(crate::Value::Bin {
+                        hint: hint.to_string(),
+                        data,
+                    });
+                } else if let Some(Value::String(data)) = record.field("data") {
+                    return Ok(crate::Value::Str {
+                        hint: hint.to_string(),
+                        data: data.to_string(),
+                    });
+                }
+            }
+            Err(format!("Invalid record: {:?}", record))
+        }
+        _ => Err(format!("Cannot convert {:?} to crate::Value", value)),
+    }
+}
diff --git a/crates/comrade/src/runtime/layer/mod.rs b/crates/comrade/src/runtime/layer/mod.rs
new file mode 100644
index 0000000..e9f84a7
--- /dev/null
+++ b/crates/comrade/src/runtime/layer/mod.rs
@@ -0,0 +1,598 @@
+//! Uses crate wasm_component_layer to run the runtime as a wasm component.
+//!
+//! This crate is great because it gives us the ability to isomorphically run in the browser with
+//! wasm_bindgen but without javascript, and also natively.
+//!
+//! That said, the entire workspace could be packaged as a component, so this can be left to the
+//! users.
+mod definitions;
+
+use definitions::{
+    either_enum, failure_variant, into_comp_value, into_core_value, success_variant, value_variant,
+};
+
+use super::Runtime;
+use crate::Error;
+use comrade_reference::{Pairs, Value};
+use wasm_component_layer::{
+    AsContextMut as _, Component, Engine, Func, FuncType, Instance, Linker, OptionType,
+    OptionValue, ResourceOwn, Store, ValueType,
+};
+
+// wasmi layer for native targets
+#[cfg(not(target_arch = "wasm32"))]
+use wasmi_runtime_layer as runtime_layer;
+
+// JS layer for the browser
+#[cfg(target_arch = "wasm32")]
+use js_wasm_runtime_layer as runtime_layer;
+
+// C and P need to be bound by Send + Sync
+pub(crate) struct Runner<C, P>
+where
+    C: Pairs,
+    P: Pairs,
+{
+    /// The store for the component.
+    store: Store<Data<C, P>, runtime_layer::Engine>,
+    /// The instantiated component.
+    instance: Instance,
+    /// The constructed API resource for the instance
+    api_resource: ResourceOwn,
+}
+
+trait Logger: Send + Sync + 'static {
+    fn log(&self, message: &str);
+}
+
+struct TracingLogger;
+
+impl Logger for TracingLogger {
+    fn log(&self, message: &str) {
+        tracing::debug!("{}", message);
+    }
+}
+
+/// Internal struct for the store Data
+struct Data<C, P>
+where
+    C: Pairs,
+    P: Pairs,
+{
+    kvp_current: C,
+    kvp_proposed: P,
+    /// Functions that are only used interally
+    logger: Box<dyn Logger>,
+}
+
+impl<C: Pairs, P: Pairs> Runner<C, P> {
+    /// Create a new wasm_compoennt_layer [Runner] with a tracing logger.
+    pub(crate) fn new(kvp_current: C, kvp_proposed: P) -> Self {
+        // Use default logger
+        Self::new_with_logger(kvp_current, kvp_proposed, Box::new(TracingLogger))
+    }
+
+    /// Create a new runner.
+    // #[cfg(test)]
+    fn new_with_logger(kvp_current: C, kvp_proposed: P, logger: Box<dyn Logger>) -> Self {
+        // target/wasm32-unknown-unknown/release/comrade_component.wasm
+        let bytes: &[u8] = include_bytes!(
+            "../../../../../target/wasm32-unknown-unknown/release/comrade_component.wasm"
+        );
+
+        // Create a new engine for instantiating a component.
+        let engine = Engine::new(runtime_layer::Engine::default());
+
+        // Create a store for managing WASM data and any custom user-defined state.
+        let mut store = Store::new(
+            &engine,
+            Data {
+                kvp_current,
+                kvp_proposed,
+                logger,
+            },
+        );
+
+        tracing::debug!("Created store, loading bytes.",);
+        // Parse the component bytes and load its imports and exports.
+        let component = Component::new(&engine, bytes).unwrap();
+
+        tracing::debug!("Loaded bytes");
+
+        // Create a linker that will be used to resolve the component's imports, if any.
+        let mut linker = Linker::default();
+
+        let host_interface = linker
+            .define_instance("comrade:api/utils".try_into().unwrap())
+            .unwrap();
+
+        host_interface
+            .define_func(
+                "log",
+                Func::new(
+                    &mut store,
+                    FuncType::new([ValueType::String], []),
+                    move |store, params, _results| {
+                        if let wasm_component_layer::Value::String(s) = &params[0] {
+                            store.data().logger.log(s.to_string().as_str());
+                        }
+                        Ok(())
+                    },
+                ),
+            )
+            .unwrap();
+
+        // func "random-byte" is defined in the host interface
+        host_interface
+            .define_func(
+                "random-byte",
+                Func::new(
+                    &mut store,
+                    FuncType::new([], [ValueType::U8]),
+                    move |_store, _params, results| {
+                        let mut random = [0u8; 1];
+                        getrandom::fill(&mut random)?;
+                        results[0] = wasm_component_layer::Value::U8(random[0]);
+                        Ok(())
+                    },
+                ),
+            )
+            .unwrap();
+
+        let pairs_interface = linker
+            .define_instance("comrade:api/pairs".try_into().unwrap())
+            .unwrap();
+
+        // get(choice: either, key: string) -> option<value>
+        // gets either the current or proposed
+        pairs_interface
+            .define_func(
+                "get",
+                Func::new(
+                    &mut store,
+                    FuncType::new(
+                        [ValueType::Enum(either_enum()), ValueType::String],
+                        [ValueType::Option(OptionType::new(ValueType::Variant(
+                            value_variant(),
+                        )))],
+                    ),
+                    move |store, params, results| {
+                        if let wasm_component_layer::Value::Enum(choice) = &params[0] {
+                            if let wasm_component_layer::Value::String(key) = &params[1] {
+                                let data = store.data();
+                                let value = match choice.discriminant() {
+                                    0 => {
+                                        tracing::debug!("[TestLog] get current");
+                                        &data.kvp_current.get(key.to_string().as_str())
+                                    }
+                                    1 => {
+                                        tracing::debug!("[TestLog] get proposed");
+                                        &data.kvp_proposed.get(key.to_string().as_str())
+                                    }
+                                    _ => panic!("Invalid choice"),
+                                };
+                                tracing::debug!("\n[TestLog] get({:?}) = {:?}\n", key, value);
+                                results[0] = match value {
+                                    Some(v) => {
+                                        let value = into_comp_value(v.clone()).unwrap();
+                                        wasm_component_layer::Value::Option(OptionValue::new(
+                                            OptionType::new(ValueType::Variant(value_variant())),
+                                            Some(value),
+                                        )?)
+                                    }
+                                    None => wasm_component_layer::Value::Option(OptionValue::new(
+                                        OptionType::new(ValueType::Variant(value_variant())),
+                                        None,
+                                    )?),
+                                };
+                            } else {
+                                panic!("Expected String, found {:?}", params[1]);
+                            }
+                        };
+                        Ok(())
+                    },
+                ),
+            )
+            .unwrap();
+
+        // put is similar to get, except it mutates the current or proposed value witht he given value
+        // and key
+        // it returns success or failure
+        pairs_interface
+            .define_func(
+                "put",
+                Func::new(
+                    &mut store,
+                    FuncType::new(
+                        [
+                            ValueType::Enum(either_enum()),
+                            ValueType::String,
+                            ValueType::Variant(value_variant()),
+                        ],
+                        [ValueType::Variant(value_variant())],
+                    ),
+                    move |mut store, params, results| {
+                        if let wasm_component_layer::Value::Enum(choice) = &params[0] {
+                            if let wasm_component_layer::Value::String(key) = &params[1] {
+                                let data = store.data_mut();
+                                let value = into_core_value(params[2].clone()).unwrap();
+                                // TODO: Store return value
+                                let _v = match choice.discriminant() {
+                                    0 => {
+                                        &mut data.kvp_current.put(key.to_string().as_str(), &value)
+                                    }
+                                    1 => {
+                                        &mut data.kvp_proposed.put(key.to_string().as_str(), &value)
+                                    }
+                                    _ => panic!("Invalid enum choice, must be current or proposed"),
+                                };
+                                results[0] = success_variant(0);
+                            } else {
+                                results[0] = failure_variant(format!(
+                                    "Expected String, found {:?}",
+                                    params[1]
+                                ));
+                            }
+                        };
+                        Ok(())
+                    },
+                ),
+            )
+            .unwrap();
+
+        // Instantiate the component with the linker and store.
+        let instance = linker.instantiate(&mut store, &component).unwrap();
+
+        // Construct
+        let exports = instance.exports();
+        let api_export_instance = exports
+            .instance(&"comrade:api/api".try_into().unwrap())
+            .unwrap();
+
+        // Call the resource constructor
+        let resource_constructor = api_export_instance.func("[constructor]api").unwrap();
+
+        let arguments = &[];
+        let mut results = vec![wasm_component_layer::Value::Bool(false)];
+
+        resource_constructor
+            .call(&mut store, arguments, &mut results)
+            .unwrap();
+
+        let api_resource = match results[0] {
+            wasm_component_layer::Value::Own(ref resource) => resource.clone(),
+            _ => panic!("Unexpected result type"),
+        };
+
+        Self {
+            store,
+            instance,
+            api_resource,
+        }
+    }
+}
+
+impl<C: Pairs, P: Pairs> Runtime for Runner<C, P> {
+    fn try_unlock(&mut self, unlock: &str) -> Result<(), Error> {
+        let api_export_instance = self
+            .instance
+            .exports()
+            .instance(&"comrade:api/api".try_into().unwrap())
+            .unwrap();
+
+        let borrowed_api = self
+            .api_resource
+            .borrow(self.store.as_context_mut())
+            .unwrap();
+
+        let unlock_args = vec![
+            wasm_component_layer::Value::Borrow(borrowed_api.clone()),
+            wasm_component_layer::Value::String(unlock.into()),
+        ];
+
+        let try_unlock = api_export_instance.func("[method]api.try-unlock").unwrap();
+
+        // Call the try_unlock method
+        let mut results = vec![wasm_component_layer::Value::Bool(false)];
+        try_unlock
+            .call(&mut self.store, &unlock_args, &mut results)
+            .unwrap();
+        Ok(())
+    }
+
+    fn try_lock(&mut self, lock: &str) -> Result<Option<Value>, Error> {
+        let api_export_instance = self
+            .instance
+            .exports()
+            .instance(&"comrade:api/api".try_into().unwrap())
+            .unwrap();
+
+        let borrowed_api = self
+            .api_resource
+            .borrow(self.store.as_context_mut())
+            .unwrap();
+
+        let lock_args = vec![
+            wasm_component_layer::Value::Borrow(borrowed_api.clone()),
+            wasm_component_layer::Value::String(lock.into()),
+        ];
+
+        let try_lock = api_export_instance.func("[method]api.try-lock").unwrap();
+
+        // Call the try_lock method
+        let mut results = vec![wasm_component_layer::Value::Bool(false)];
+        try_lock.call(&mut self.store, &lock_args, &mut results)?;
+
+        // allow unused assignment
+        #[allow(unused_assignments)]
+        let mut res = None;
+
+        if let wasm_component_layer::Value::Result(result) = &results[0] {
+            match **result {
+                Ok(ref v) => {
+                    let Some(v) = v else {
+                        return Err(Error::ScriptFailure("Unlock failed".to_string()));
+                    };
+                    let comrade_value = into_core_value(v.clone()).unwrap();
+                    res = Some(comrade_value.clone());
+                }
+                Err(ref e) => {
+                    // Unlock failed with error: {:?}", e.as_ref().unwrap());
+                    return Err(Error::ScriptFailure(format!(
+                        "Unlock failed with error: {:?}",
+                        e.as_ref().unwrap()
+                    )));
+                }
+            }
+        } else {
+            return Err(Error::ScriptFailure(format!(
+                "Expected Result, found {:?}",
+                results[0]
+            )));
+        };
+
+        Ok(res)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::HashMap;
+    use std::sync::Arc;
+
+    use comrade_reference::Pairs;
+
+    use super::*;
+    use crate::runtime::Runtime;
+
+    struct TestLogger {
+        messages: Arc<std::sync::Mutex<Vec<String>>>,
+    }
+
+    impl TestLogger {
+        fn new() -> Self {
+            Self {
+                messages: Arc::new(std::sync::Mutex::new(Vec::new())),
+            }
+        }
+
+        fn get_messages(&self) -> Vec<String> {
+            let lock = self.messages.lock().unwrap();
+            lock.clone()
+        }
+
+        fn clear_messages(&self) {
+            let mut lock = self.messages.lock().unwrap();
+            lock.clear();
+        }
+    }
+
+    impl Logger for TestLogger {
+        fn log(&self, message: &str) {
+            eprintln!("[TestLogger]: {}", message);
+            let mut messages = self.messages.lock().unwrap();
+            messages.push(message.to_string());
+        }
+    }
+
+    impl Clone for TestLogger {
+        fn clone(&self) -> Self {
+            Self {
+                messages: Arc::clone(&self.messages),
+            }
+        }
+    }
+
+    impl<C: Pairs, P: Pairs> Runner<C, P> {
+        // Helper for tests that returns both the runner and the logger
+        fn new_for_test(kvp_current: C, kvp_proposed: P) -> (Self, TestLogger) {
+            let test_logger = TestLogger::new();
+            let logger_box: Box<dyn Logger> = Box::new(test_logger.clone());
+
+            let runner = Self::new_with_logger(kvp_current, kvp_proposed, logger_box);
+            (runner, test_logger)
+        }
+    }
+
+    #[derive(Clone, Default, Debug)]
+    struct TestData(HashMap<String, Value>);
+
+    impl Pairs for TestData {
+        fn get(&self, key: &str) -> Option<Value> {
+            self.0.get(key).cloned()
+        }
+
+        fn put(&mut self, key: &str, value: &Value) -> Option<Value> {
+            self.0.insert(key.to_string(), value.clone())
+        }
+    }
+
+    fn unlock_script(entry_key: &str, proof_key: &str) -> String {
+        let unlock_script = format!(
+            r#"
+                // push the serialized Entry as the message
+                push("{entry_key}"); 
+
+                // push the proof data
+                push("{proof_key}");
+            "#
+        );
+
+        unlock_script
+    }
+
+    /// First lock is /ephemeral and {entry_key}
+    fn first_lock_script(entry_key: &str) -> String {
+        let first_lock = format!(
+            r#"
+                // check the first key, which is ephemeral
+                check_signature("/ephemeral", "{entry_key}") 
+            "#
+        );
+
+        first_lock
+    }
+
+    /// Other lock script
+    fn other_lock_script(entry_key: &str) -> String {
+        format!(
+            r#"
+                // then check a possible threshold sig...
+                check_signature("/recoverykey", "{entry_key}") ||
+
+                // then check a possible pubkey sig...
+                check_signature("/pubkey", "{entry_key}") ||
+                
+                // then the pre-image proof...
+                check_preimage("/hash")
+            "#
+        )
+    }
+
+    #[test]
+    fn test_layer_runner() {
+        let mut runner = Runner::new(TestData::default(), TestData::default());
+        let entry_key = "/entry/";
+        assert!(runner.try_lock(&first_lock_script(entry_key)).is_ok());
+        let proof_key = "/entry/proof";
+        assert!(runner
+            .try_unlock(&unlock_script(entry_key, proof_key))
+            .is_ok());
+    }
+
+    #[test]
+    fn test_fails_for_invalid_script() {
+        let mut runner = Runner::new(TestData::default(), TestData::default());
+        assert!(runner.try_lock("garbage").is_err());
+    }
+
+    #[test]
+    fn test_log() {
+        // When we call the consturctor for the reference impl wasm bytes,
+        // we should get log("Creating new Component");
+
+        let (_runner, test_logger) = Runner::new_for_test(TestData::default(), TestData::default());
+
+        let logs = test_logger.get_messages();
+
+        assert!(logs
+            .iter()
+            .any(|msg| msg.contains("Creating new Component")));
+    }
+
+    // try_unlock
+    #[test]
+    fn test_try_unlock_and_lock_scripts() {
+        let entry_key = "/entry/";
+
+        // unlock details
+        let entry_data = b"for great justice, move every zig!";
+        let proof_key = "/entry/proof";
+        let proof_data = hex::decode("b92483a6c006000100404819397f51b18bc6cffd1fff07afa33f7096c7a0c659590b077cc0ea5d6081d739512129becacb8e6997e6b7d18756299f515a822344ac2b6737979d5e5e6b03").unwrap();
+
+        let pubkey = "/pubkey";
+        let pub_key = hex::decode("ba24ed010874657374206b657901012054d94d7b8a11d6581af4a14bc6451c7a23049018610f108c996968fe8fce9464").unwrap();
+
+        let unlock = format!(
+            r#"
+        // push the serialized Entry as the message
+        push("{entry_key}");
+
+        // push the proof data
+        push("{entry_key}proof");"#
+        );
+
+        let mut kvp_unlock = TestData::default();
+        let mut kvp_lock = TestData::default();
+        // "/entry/" needs to be present on both lock and unlock stacks,
+        // since they are used in both the unlock and lock scripts:
+        // ie. push("/entry/") and check_signature("/pubkey", "/entry/")
+        kvp_unlock.put(entry_key, &entry_data.to_vec().into());
+        kvp_lock.put(entry_key, &entry_data.to_vec().into());
+        // "/entry/proof" only needs to be present on the unlock stack,
+        // since that's where the proof is used
+        kvp_unlock.put(proof_key, &proof_data.clone().into());
+
+        kvp_lock.put(pubkey, &pub_key.into());
+
+        let (mut runner, test_logger) = Runner::new_for_test(kvp_lock, kvp_unlock);
+
+        let result = runner.try_unlock(&unlock);
+
+        // Check the result
+        assert!(result.is_ok());
+
+        // Parameter stack now has /entry/ and /entry/proof on it,
+        // but that's transparent to us at this level
+        // The only way we confirm our code works is if the valid lock script
+        // succeeds, and invalid lock script fails
+
+        // 2 lock scripts.
+        // First one shodl fail, since we don't have the ephemeral key
+        // Second one should succeed, since we have the pubkey signature
+        let first_lock = format!(
+            r#"
+                // check the first key, which is ephemeral
+                check_signature("/ephemeral", "{entry_key}") 
+            "#
+        );
+
+        let other_lock = format!(
+            r#"
+                // then check a possible threshold sig...
+                check_signature("/recoverykey", "{entry_key}") ||
+
+                // then check a possible pubkey sig...
+                check_signature("/pubkey", "{entry_key}") ||
+                
+                // then the pre-image proof...
+                check_preimage("/hash")
+            "#
+        );
+
+        // First lock script should Result in a fail Value
+        let maybe_result = runner.try_lock(&first_lock).unwrap();
+        assert!(maybe_result.is_some());
+        let value = maybe_result.unwrap();
+
+        // value should be a failure variant
+        let Value::Failure(reason) = value else {
+            panic!("Expected a failure variant");
+        };
+
+        eprintln!("First lock script failed with reason: {}", reason);
+
+        // Second lock script should Result in a success Value
+        let value = runner.try_lock(&other_lock).unwrap().unwrap();
+
+        // value should be a success variant with a count
+        let Value::Success(count) = value else {
+            panic!("Expected a success variant {value:?}");
+        };
+
+        eprintln!("Second lock script succeeded with count: {}", count);
+
+        // Count should be 2, since 1) /ephemeral failed, 2) /recoverykey failed
+        assert_eq!(count, 2);
+    }
+}
diff --git a/crates/comrade/src/runtime/mod.rs b/crates/comrade/src/runtime/mod.rs
new file mode 100644
index 0000000..f22d371
--- /dev/null
+++ b/crates/comrade/src/runtime/mod.rs
@@ -0,0 +1,36 @@
+//! Comrade Virutal runtime which manages running of the script using the chosen wasm component.
+use crate::Error;
+use comrade_reference::Value;
+
+/// The "Direct" runtime is the default runtime for Comrade.
+/// It uses the comrade-reference implementation directlt in rust
+/// without any wasm component.
+///
+/// This way, we can run the entire workspace in rust without any wasm,
+/// or as a wasm component itself.
+mod direct;
+pub(crate) use direct::Runner;
+
+// NOTE: In the future, we could support other runtimes at this level,
+// but it may only make sense to do so once there is demand for different backends.
+// For example, the wasm runtime can use a wasm component layer to run the script
+// instead of native rust code. This gives us a swappable interface in case a user
+// wants a particular runtime for their use case which ours doesn't support.
+// #[cfg(feature = "runtime-wasm")]
+// mod layer;
+// #[cfg(feature = "runtime-wasm")]
+// pub(crate) use layer::Runner;
+// Or other wasm runtimes can be used:
+// mod wasmtime;
+// mod wasm_i;
+// mod wasmer;
+
+/// Each runtime feature must implement the `Runtime` trait, to maintain a common interface.
+pub trait Runtime {
+    /// Sets the domain
+    fn with_domain(&mut self, domain: &str);
+    /// Run the script.
+    fn try_unlock(&mut self, script: &str) -> Result<(), Error>;
+    /// Get the top value from the context return stack.
+    fn try_lock(&mut self, script: &str) -> Result<Option<Value>, Error>;
+}
diff --git a/crates/comrade/tests/web.rs b/crates/comrade/tests/web.rs
new file mode 100644
index 0000000..72b643a
--- /dev/null
+++ b/crates/comrade/tests/web.rs
@@ -0,0 +1,54 @@
+//! Test to ensure that the crate runs in wasm32 target
+#![cfg(target_arch = "wasm32")]
+
+use wasm_bindgen_test::wasm_bindgen_test_configure;
+use wasm_bindgen_test::*;
+
+wasm_bindgen_test_configure!(run_in_browser);
+
+use comrade_reference::{Pairs, Value};
+use std::collections::HashMap;
+use tracing::info;
+
+use comrade::wasm_tests::run as run_wasm_tests;
+
+// Test which checks autotrait implementation for all types
+fn is_not_send<T: Sized + Unpin>() {}
+
+fn init_tracing() {
+    // Set up panic hook for better error messages
+    console_error_panic_hook::set_once();
+
+    // Initialize the tracing subscriber with console output
+    tracing_wasm::set_as_global_default();
+}
+
+#[wasm_bindgen_test]
+fn test_wasm_autotraits() {
+    // This is a dummy test to ensure that the crate runs in wasm32 target
+    // and that the autotrait implementation is what is expected.
+    #[derive(Clone, Debug, Default)]
+    struct ContextPairs(HashMap<String, Value>);
+
+    impl Pairs for ContextPairs {
+        fn get(&self, key: &str) -> Option<Value> {
+            self.0.get(key).cloned()
+        }
+
+        fn put(&mut self, key: &str, value: &Value) -> Option<Value> {
+            self.0.insert(key.to_string(), value.clone())
+        }
+    }
+
+    is_not_send::<comrade::Comrade<'_>>();
+}
+
+#[wasm_bindgen_test]
+fn web_test() {
+    init_tracing();
+
+    tracing::info!("Starting web_test");
+
+    // Import and run the same tests that are in lib.rs
+    comrade::wasm_tests::run();
+}
diff --git a/crates/multicid/src/serde/ser.rs b/crates/multicid/src/serde/ser.rs
index efa5ed6..39178d1 100644
--- a/crates/multicid/src/serde/ser.rs
+++ b/crates/multicid/src/serde/ser.rs
@@ -17,6 +17,8 @@ impl ser::Serialize for Cid {
         } else {
             #[cfg(feature = "dag_cbor")]
             {
+                use multicodec::Codec;
+
                 // build the byte string for DAG-CBOR according to the spec
                 // https://github.com/ipld/specs/blob/master/block-layer/codecs/dag-cbor.md#links
                 let mut v = Vec::new();
diff --git a/crates/provenance-log/Cargo.toml b/crates/provenance-log/Cargo.toml
index e1615a7..04a4f30 100644
--- a/crates/provenance-log/Cargo.toml
+++ b/crates/provenance-log/Cargo.toml
@@ -28,6 +28,7 @@ test-log.workspace = true
 thiserror.workspace = true
 tracing.workspace = true
 wacc.workspace = true
+comrade.workspace = true
 
 [dev-dependencies]
 hex.workspace = true
diff --git a/crates/provenance-log/src/entry.rs b/crates/provenance-log/src/entry.rs
index 9651cc9..1c246d1 100644
--- a/crates/provenance-log/src/entry.rs
+++ b/crates/provenance-log/src/entry.rs
@@ -94,19 +94,19 @@ impl EncodingInfo for Entry {
     }
 }
 
-impl wacc::Pairs for Entry {
-    fn get(&self, key: &str) -> Option<wacc::Value> {
+impl comrade::Pairs for &Entry {
+    fn get(&self, key: &str) -> Option<comrade::Value> {
         let key = match Key::try_from(key) {
             Ok(key) => key,
             Err(_) => return None,
         };
         match self.get_value(&key) {
             Some(value) => match value {
-                Value::Data(data) => Some(wacc::Value::Bin {
+                Value::Data(data) => Some(comrade::Value::Bin {
                     hint: key.to_string(),
                     data,
                 }),
-                Value::Str(s) => Some(wacc::Value::Str {
+                Value::Str(s) => Some(comrade::Value::Str {
                     hint: key.to_string(),
                     data: s,
                 }),
@@ -116,7 +116,7 @@ impl wacc::Pairs for Entry {
         }
     }
 
-    fn put(&mut self, _key: &str, _value: &wacc::Value) -> Option<wacc::Value> {
+    fn put(&mut self, _key: &str, _value: &comrade::Value) -> Option<comrade::Value> {
         None
     }
 }
diff --git a/crates/provenance-log/src/error.rs b/crates/provenance-log/src/error.rs
index 72cb453..fdddeff 100644
--- a/crates/provenance-log/src/error.rs
+++ b/crates/provenance-log/src/error.rs
@@ -164,6 +164,12 @@ pub enum LogError {
     /// Updating kvp failed
     #[error("Kvp set entry failed {0}")]
     KvpSetEntryFailed(String),
+    /// Running the unlock script failed
+    #[error("Running the unlock script failed, reason: {0}")]
+    UnlockFailed(String),
+    /// Running the lock script failed
+    #[error("Running the lock script failed, reason: {0}")]
+    LockFailed(String),
 }
 
 /// Errors created by this library
@@ -206,6 +212,14 @@ pub enum ScriptError {
     /// invalid wasm script magic value
     #[error("invalid wasm script")]
     InvalidScriptMagic,
+    /// Wrong script format
+    #[error("wrong script format: expected {expected}, found {found}")]
+    WrongScriptFormat {
+        /// The String that was found
+        found: String,
+        /// The String that was expected
+        expected: String,
+    },
 }
 
 /// Errors created by this library
diff --git a/crates/provenance-log/src/lib.rs b/crates/provenance-log/src/lib.rs
index b2b8704..9b9ef79 100644
--- a/crates/provenance-log/src/lib.rs
+++ b/crates/provenance-log/src/lib.rs
@@ -44,10 +44,6 @@ pub use script::{EncodedScript, Script, ScriptId};
 #[cfg(feature = "serde")]
 pub mod serde;
 
-/// The parameter and return value stack type
-pub mod stack;
-pub use stack::Stk;
-
 /// Entry Value related functions
 pub mod value;
 pub use value::{Value, ValueId};
diff --git a/crates/provenance-log/src/log.rs b/crates/provenance-log/src/log.rs
index 3e94281..632c8a8 100644
--- a/crates/provenance-log/src/log.rs
+++ b/crates/provenance-log/src/log.rs
@@ -1,5 +1,10 @@
 // SPDX-License-Identifier: FSL-1.1
-use crate::{entry, error::LogError, Entry, Error, Kvp, Script, Stk};
+use crate::{
+    entry,
+    error::{LogError, ScriptError},
+    Entry, Error, Kvp, Script,
+};
+use comrade::{Comrade, Value};
 use core::fmt;
 use multibase::Base;
 use multicid::{Cid, Vlad};
@@ -7,7 +12,6 @@ use multicodec::Codec;
 use multitrait::{Null, TryDecodeFrom};
 use multiutil::{BaseEncoded, CodecInfo, EncodingInfo, Varuint};
 use std::collections::BTreeMap;
-use wacc::{prelude::StoreLimitsBuilder, vm, Stack};
 
 /// the multicodec provenance log codec
 pub const SIGIL: Codec = Codec::ProvenanceLog;
@@ -189,11 +193,27 @@ struct VerifyIter<'a> {
     entries: Vec<&'a Entry>,
     seqno: usize,
     prev_seqno: usize,
+    prev_cid: Cid,
     kvp: Kvp<'a>,
     lock_scripts: Vec<Script>,
     error: Option<Error>,
 }
 
+impl<'a> VerifyIter<'a> {
+    /// Helper method to set error state and return early
+    fn set_error<E>(&mut self, error: E) -> Option<Result<(usize, Entry, Kvp<'a>), Error>>
+    where
+        E: Into<Error>,
+    {
+        // Set index out of range
+        self.seqno = self.entries.len();
+        // Set the error state
+        self.error = Some(error.into());
+        // Return the error
+        Some(Err(self.error.clone().unwrap()))
+    }
+}
+
 impl<'a> Iterator for VerifyIter<'a> {
     type Item = Result<(usize, Entry, Kvp<'a>), Error>;
 
@@ -207,216 +227,89 @@ impl<'a> Iterator for VerifyIter<'a> {
         // this is the check count if successful
         let mut count = 0;
 
-        // set up the stacks
-        let mut pstack = Stk::default();
-        let mut rstack = Stk::default();
-
         // check the seqno meet the criteria
         if self.seqno > 0 && self.seqno != self.prev_seqno + 1 {
-            // set our index out of range
-            self.seqno = self.entries.len();
-            // set the error state
-            self.error = Some(LogError::InvalidSeqno.into());
-            return Some(Err(self.error.clone().unwrap()));
+            return self.set_error(LogError::InvalidSeqno);
         }
 
-        // 'unlock:
-        let mut result = {
-            // run the unlock script using the entry as the kvp to get the
-            // stack in the vm::Context set up.
-            let unlock_ctx = vm::Context {
-                current: entry,  // limit the available data to just the entry
-                proposed: entry, // limit the available data to just the entry
-                pstack: &mut pstack,
-                rstack: &mut rstack,
-                check_count: 0,
-                write_idx: 0,
-                context: entry.context().to_string(),
-                log: Vec::default(),
-                limiter: StoreLimitsBuilder::new()
-                    .memory_size(1 << 16)
-                    .instances(2)
-                    .memories(1)
-                    .build(),
-            };
-
-            let mut instance = match vm::Builder::new()
-                .with_context(unlock_ctx)
-                .with_bytes(entry.unlock.clone())
-                .try_build()
-            {
-                Ok(i) => i,
-                Err(e) => {
-                    // set our index out of range
-                    self.seqno = self.entries.len();
-                    self.error = Some(LogError::Wacc(e).into());
-                    return Some(Err(self.error.clone().unwrap()));
-                }
-            };
-            //print!("running unlock script from seqno: {}...", self.seqno);
-
-            // run the unlock script
-            if let Some(e) = instance.run("for_great_justice").err() {
-                // set our index out of range
-                self.seqno = self.entries.len();
-                self.error = Some(LogError::Wacc(e).into());
-                return Some(Err(self.error.clone().unwrap()));
-            }
-
-            //println!("SUCCEEDED!");
-
-            true
-        };
-
-        /*
-        println!("values:");
-        println!("{:?}", pstack.clone());
-        println!("return:");
-        println!("{:?}", rstack.clone());
-        */
-
-        if !result {
-            // set our index out of range
-            self.seqno = self.entries.len();
-            self.error = Some(
-                LogError::VerifyFailed(format!(
-                    "unlock script failed\nvalues:\n{:?}\nreturn:\n{:?}",
-                    rstack, pstack
-                ))
-                .into(),
-            );
-            return Some(Err(self.error.clone().unwrap()));
+        // check if the cid meets the criteria
+        if self.seqno > 0 && entry.prev() != self.prev_cid {
+            return self.set_error(LogError::EntryCidMismatch);
         }
 
-        /*
-        // set the entry to look into for proof and message values
-        if let Some(e) = self.kvp.set_entry(entry).err() {
-            // set our index out of range
-            self.seqno = self.entries.len();
-            self.error = Some(LogError::KvpSetEntryFailed(e.to_string()).into());
-            return Some(Err(self.error.clone().unwrap()));
-        }
-        */
+        // 'unlock:
+        let Script::Code(_, ref unlock) = entry.unlock else {
+            return self.set_error(ScriptError::WrongScriptFormat {
+                expected: "unlock".to_string(),
+                found: format!("{:?}", entry.unlock),
+            });
+        };
 
         // if this is the first entry, then we need to apply the
         // mutation ops
         if self.seqno == 0 {
             //println!("applying kvp ops for seqno 0");
             if let Some(e) = self.kvp.apply_entry_ops(entry).err() {
-                // set our index out of range
-                self.seqno = self.entries.len();
-                self.error = Some(LogError::UpdateKvpFailed(e.to_string()).into());
-                return Some(Err(self.error.clone().unwrap()));
+                return self.set_error(LogError::UnlockFailed(e.to_string()));
             }
         }
 
-        // 'lock:
-        result = false;
+        let kvp_lock = self.kvp.clone();
+
+        let mut unlocked = Comrade::new(&kvp_lock, &entry)
+            .try_unlock(unlock)
+            .map_err(|e| self.set_error(LogError::UnlockFailed(format!("unlock failed: {}", e))))
+            .ok()?;
 
         // build the set of lock scripts to run in order from root to longest branch to leaf
         let locks = match entry.sort_locks(&self.lock_scripts) {
             Ok(l) => l,
             Err(e) => {
-                // set our index out of range
-                self.seqno = self.entries.len();
-                self.error = Some(e);
-                return Some(Err(self.error.clone().unwrap()));
+                return self.set_error(e);
             }
         };
 
+        let mut results = false;
+
         // run each of the lock scripts
         for lock in locks {
-            // NOTE: clone the kvp and stacks each time
-            let lock_kvp = self.kvp.clone();
-            let mut lock_pstack = pstack.clone();
-            let mut lock_rstack = rstack.clone();
-
-            {
-                let lock_ctx = vm::Context {
-                    current: &lock_kvp,
-                    proposed: entry,
-                    pstack: &mut lock_pstack,
-                    rstack: &mut lock_rstack,
-                    check_count: 0,
-                    write_idx: 0,
-                    context: entry.context().to_string(), // set the branch path for branch()
-                    log: Vec::default(),
-                    limiter: StoreLimitsBuilder::new()
-                        .memory_size(1 << 16)
-                        .instances(2)
-                        .memories(1)
-                        .build(),
-                };
-
-                let mut instance = match vm::Builder::new()
-                    .with_context(lock_ctx)
-                    .with_bytes(lock.clone())
-                    .try_build()
-                {
-                    Ok(i) => i,
-                    Err(e) => {
-                        // set our index out of range
-                        self.seqno = self.entries.len();
-                        self.error = Some(LogError::Wacc(e).into());
-                        return Some(Err(self.error.clone().unwrap()));
-                    }
-                };
-                //print!("running lock script from seqno: {}...", self.seqno);
-
-                // run the unlock script
-                if let Some(e) = instance.run("move_every_zig").err() {
-                    // set our index out of range
-                    self.seqno = self.entries.len();
-                    self.error = Some(LogError::Wacc(e).into());
-                    return Some(Err(self.error.clone().unwrap()));
-                }
-
-                //println!("SUCCEEDED!");
-            }
+            let Script::Code(_, lock) = lock else {
+                return self.set_error(ScriptError::WrongScriptFormat {
+                    found: format!("{:?}", lock),
+                    expected: "Script::Code".to_string(),
+                });
+            };
 
-            // break out of this loop as soon as a lock script succeeds
-            if let Some(v) = lock_rstack.top() {
-                match v {
-                    vm::Value::Success(c) => {
-                        count = c;
-                        result = true;
-                        break;
-                    }
-                    _ => result = false,
+            match unlocked.try_lock(&lock) {
+                Ok(Some(Value::Success(ct))) => {
+                    count = ct;
+                    results = true;
+                    break;
                 }
+                Err(e) => {
+                    self.set_error(LogError::LockFailed(e.to_string()));
+                }
+                _ => continue,
             }
         }
 
-        if result {
-            // if the entry verifies, apply it's mutataions to the kvp
-            // the 0th entry has already been applied at this point so no
-            // need to do it here
-            if self.seqno > 0 {
-                if let Some(e) = self.kvp.apply_entry_ops(entry).err() {
-                    // set our index out of range
-                    self.seqno = self.entries.len();
-                    self.error = Some(LogError::UpdateKvpFailed(e.to_string()).into());
-                    return Some(Err(self.error.clone().unwrap()));
-                }
-            }
-            // update the lock script to validate the next entry
-            self.lock_scripts.clone_from(&entry.locks);
-            // update the seqno
-            self.prev_seqno = self.seqno;
-            self.seqno += 1;
-        } else {
-            // set our index out of range
-            self.seqno = self.entries.len();
-            self.error = Some(
-                LogError::VerifyFailed(format!(
-                    "unlock script failed\nvalues:\n{:?}\nreturn:\n{:?}",
-                    rstack, pstack
-                ))
-                .into(),
-            );
-            return Some(Err(self.error.clone().unwrap()));
+        if !results {
+            self.set_error(LogError::VerifyFailed("entry failed to verify".to_string()));
         }
 
+        // if the entry verifies, apply it's mutataions to the kvp
+        // the 0th entry has already been applied at this point so no
+        // need to do it here
+        if self.seqno > 0 {
+            if let Some(e) = self.kvp.apply_entry_ops(entry).err() {
+                return self.set_error(LogError::UpdateKvpFailed(e.to_string()));
+            }
+        }
+        // update the lock script to validate the next entry
+        self.lock_scripts.clone_from(&entry.locks);
+        // update the seqno
+        self.prev_seqno = self.seqno;
+        self.seqno += 1;
         // return the check count, validated entry, and kvp state
         Some(Ok((count, entry.clone(), self.kvp.clone())))
     }
@@ -443,6 +336,7 @@ impl Log {
             entries,
             seqno: 0,
             prev_seqno: 0,
+            prev_cid: Cid::null(),
             kvp: Kvp::default(),
             lock_scripts: vec![self.first_lock.clone()],
             error: None,
diff --git a/crates/provenance-log/src/pairs.rs b/crates/provenance-log/src/pairs.rs
index c4f62b4..5d7379b 100644
--- a/crates/provenance-log/src/pairs.rs
+++ b/crates/provenance-log/src/pairs.rs
@@ -14,23 +14,23 @@ pub struct Kvp<'a> {
     undo: Vec<(Option<&'a Entry>, BTreeMap<Key, Value>)>,
 }
 
-impl wacc::Pairs for Kvp<'_> {
-    fn get(&self, key: &str) -> Option<wacc::Value> {
+impl comrade::Pairs for Kvp<'_> {
+    fn get(&self, key: &str) -> Option<comrade::Value> {
         let k = match Key::try_from(key) {
             Ok(k) => k,
             _ => return None,
         };
         match self.kvp.get(&k) {
             Some(ref v) => match v {
-                Value::Nil => Some(wacc::Value::Bin {
+                Value::Nil => Some(comrade::Value::Bin {
                     hint: key.to_string(),
                     data: Vec::default(),
                 }),
-                Value::Str(ref s) => Some(wacc::Value::Str {
+                Value::Str(ref s) => Some(comrade::Value::Str {
                     hint: key.to_string(),
                     data: s.clone(),
                 }),
-                Value::Data(ref v) => Some(wacc::Value::Bin {
+                Value::Data(ref v) => Some(comrade::Value::Bin {
                     hint: key.to_string(),
                     data: v.clone(),
                 }),
@@ -45,32 +45,32 @@ impl wacc::Pairs for Kvp<'_> {
         }
     }
 
-    fn put(&mut self, key: &str, value: &wacc::Value) -> Option<wacc::Value> {
+    fn put(&mut self, key: &str, value: &comrade::Value) -> Option<comrade::Value> {
         let k = match Key::try_from(key) {
             Ok(k) => k,
             _ => return None,
         };
         let v = match value {
-            wacc::Value::Str {
+            comrade::Value::Str {
                 hint: _,
                 data: ref s,
             } => Value::Str(s.clone()),
-            wacc::Value::Bin {
+            comrade::Value::Bin {
                 hint: _,
                 data: ref v,
             } => Value::Data(v.clone()),
             _ => return None,
         };
         match self.kvp.insert(k, v) {
-            Some(Value::Nil) => Some(wacc::Value::Bin {
+            Some(Value::Nil) => Some(comrade::Value::Bin {
                 hint: key.to_string(),
                 data: Vec::default(),
             }),
-            Some(Value::Str(s)) => Some(wacc::Value::Str {
+            Some(Value::Str(s)) => Some(comrade::Value::Str {
                 hint: key.to_string(),
                 data: s,
             }),
-            Some(Value::Data(v)) => Some(wacc::Value::Bin {
+            Some(Value::Data(v)) => Some(comrade::Value::Bin {
                 hint: key.to_string(),
                 data: v,
             }),
diff --git a/justfile b/justfile
new file mode 100644
index 0000000..4309db5
--- /dev/null
+++ b/justfile
@@ -0,0 +1,5 @@
+# Build Script 
+build:
+  # Calls the just command in crates/comrade-component (just build): 
+  just crates/comrade-component/build
+