diff --git a/.github/workflows/audit.yml b/.github/workflows/audit.yml
index 05ed21067..7c5f9a4a5 100644
--- a/.github/workflows/audit.yml
+++ b/.github/workflows/audit.yml
@@ -1,9 +1,6 @@
 name: Audit
 on:
-  pull_request:
-  push:
-  schedule:
-    - cron: '0 */12 * * *'
+  workflow_dispatch:
 jobs:
   audit:
     runs-on: ubuntu-latest
diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index 013678635..e501ab982 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -1,5 +1,8 @@
 name: Benchmark
 on:
+  push:
+    branches:
+      - 'main'
   workflow_dispatch:
 env:
   CARGO_TERM_COLOR: always
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 400622a32..f7a5d0fc6 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -6,6 +6,7 @@ on:
       - 'main'
   schedule:
     - cron: '0 0 * * */2'
+  workflow_dispatch:
 concurrency:
   group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
   cancel-in-progress: true
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 1eea8b658..4f0a29444 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 ### Added
 - [\#206](https://github.com/Manta-Network/manta-rs/pull/206) Move Poseidon sage script to test the hardcoded round constant values. 
 - [\#172](https://github.com/Manta-Network/manta-rs/pull/172) Add abstract Phase 2 for Groth16 trusted setup 
+- [\#197](https://github.com/Manta-Network/manta-rs/pull/197) Add ECLAIR utilities for next circuit upgrade
 
 ### Changed
 - [\#180](https://github.com/Manta-Network/manta-rs/pull/180) Start moving to new `arkworks` backend for `manta-crypto`
diff --git a/manta-accounting/src/transfer/mod.rs b/manta-accounting/src/transfer/mod.rs
index 75f89d558..904023a90 100644
--- a/manta-accounting/src/transfer/mod.rs
+++ b/manta-accounting/src/transfer/mod.rs
@@ -34,7 +34,7 @@ use alloc::vec::Vec;
 use core::{fmt::Debug, hash::Hash, marker::PhantomData, ops::Deref};
 use manta_crypto::{
     accumulator::{self, AssertValidVerification, MembershipProof, Model},
-    constraint::{ProofSystem, ProofSystemInput},
+    constraint::{HasInput, ProofSystem},
     eclair::{
         self,
         alloc::{
@@ -236,12 +236,12 @@ pub trait Configuration {
 
     /// Proof System Type
     type ProofSystem: ProofSystem<Compiler = Self::Compiler>
-        + ProofSystemInput<AssetId>
-        + ProofSystemInput<AssetValue>
-        + ProofSystemInput<UtxoAccumulatorOutput<Self>>
-        + ProofSystemInput<Utxo<Self>>
-        + ProofSystemInput<VoidNumber<Self>>
-        + ProofSystemInput<PublicKey<Self>>;
+        + HasInput<AssetId>
+        + HasInput<AssetValue>
+        + HasInput<UtxoAccumulatorOutput<Self>>
+        + HasInput<Utxo<Self>>
+        + HasInput<VoidNumber<Self>>
+        + HasInput<PublicKey<Self>>;
 
     /// Note Base Encryption Scheme Type
     type NoteEncryptionScheme: encryption::Encrypt<
@@ -297,8 +297,7 @@ pub type UtxoAccumulatorOutput<C> =
 pub type UtxoMembershipProof<C> = MembershipProof<<C as Configuration>::UtxoAccumulatorModel>;
 
 /// UTXO Membership Proof Variable Type
-pub type UtxoMembershipProofVar<C> =
-    MembershipProof<<C as Configuration>::UtxoAccumulatorModelVar, Compiler<C>>;
+pub type UtxoMembershipProofVar<C> = MembershipProof<<C as Configuration>::UtxoAccumulatorModelVar>;
 
 /// Encrypted Note Type
 pub type EncryptedNote<C> = EncryptedMessage<
diff --git a/manta-accounting/src/transfer/receiver.rs b/manta-accounting/src/transfer/receiver.rs
index 251b0b1f6..c7b4a813a 100644
--- a/manta-accounting/src/transfer/receiver.rs
+++ b/manta-accounting/src/transfer/receiver.rs
@@ -25,8 +25,7 @@ use crate::{
 };
 use core::{fmt::Debug, hash::Hash, iter};
 use manta_crypto::{
-    accumulator::Accumulator,
-    constraint::ProofSystemInput,
+    constraint::HasInput,
     eclair::{
         alloc::{
             mode::{Derived, Public},
@@ -97,16 +96,6 @@ where
         self.encrypted_note.ephemeral_public_key()
     }
 
-    /// Returns `true` whenever `self.utxo` and `rhs.utxo` can be inserted in any order into the
-    /// `utxo_accumulator`.
-    #[inline]
-    pub fn is_independent_from<A>(&self, rhs: &Self, utxo_accumulator: &A) -> bool
-    where
-        A: Accumulator<Item = Utxo<C>, Model = C::UtxoAccumulatorModel>,
-    {
-        utxo_accumulator.are_independent(&self.utxo, &rhs.utxo)
-    }
-
     /// Extracts the ledger posting data from `self`.
     #[inline]
     pub fn into_post(self) -> ReceiverPost<C> {
diff --git a/manta-accounting/src/transfer/sender.rs b/manta-accounting/src/transfer/sender.rs
index e438ccd65..7a4ba0ffd 100644
--- a/manta-accounting/src/transfer/sender.rs
+++ b/manta-accounting/src/transfer/sender.rs
@@ -27,7 +27,7 @@ use crate::{
 use core::{fmt::Debug, hash::Hash, iter};
 use manta_crypto::{
     accumulator::Accumulator,
-    constraint::ProofSystemInput,
+    constraint::HasInput,
     eclair::{
         alloc::{mode::Derived, Allocate, Allocator, Variable},
         bool::AssertEq,
@@ -142,16 +142,6 @@ where
             None
         }
     }
-
-    /// Returns `true` whenever `self.utxo` and `rhs.utxo` can be inserted in any order into the
-    /// `utxo_accumulator`.
-    #[inline]
-    pub fn is_independent_from<A>(&self, rhs: &Self, utxo_accumulator: &A) -> bool
-    where
-        A: Accumulator<Item = Utxo<C>, Model = C::UtxoAccumulatorModel>,
-    {
-        utxo_accumulator.are_independent(&self.utxo, &rhs.utxo)
-    }
 }
 
 /// Sender Proof
@@ -211,16 +201,6 @@ where
         self.asset.value
     }
 
-    /// Returns `true` whenever `self.utxo` and `rhs.utxo` can be inserted in any order into the
-    /// `utxo_accumulator`.
-    #[inline]
-    pub fn is_independent_from<A>(&self, rhs: &Self, utxo_accumulator: &A) -> bool
-    where
-        A: Accumulator<Item = Utxo<C>, Model = C::UtxoAccumulatorModel>,
-    {
-        utxo_accumulator.are_independent(&self.utxo, &rhs.utxo)
-    }
-
     /// Reverts `self` back into a [`PreSender`].
     ///
     /// This method should be called if the [`Utxo`] membership proof attached to `self` was deemed
diff --git a/manta-crypto/Cargo.toml b/manta-crypto/Cargo.toml
index 05738b9b0..9d3a4c41a 100644
--- a/manta-crypto/Cargo.toml
+++ b/manta-crypto/Cargo.toml
@@ -59,4 +59,5 @@ rand_core = { version = "0.6.3", default-features = false }
 workspace-hack = { version = "0.1.0", path = "../workspace-hack" }
 
 [dev-dependencies]
-rand = "0.8.4"
+ark-bn254 = { version = "0.3.0", default-features = false, features = ["scalar_field"] }
+manta-crypto = { path = ".", default-features = false, features = ["getrandom"] }
diff --git a/manta-crypto/src/accumulator.rs b/manta-crypto/src/accumulator.rs
index 1e31d3358..f14381523 100644
--- a/manta-crypto/src/accumulator.rs
+++ b/manta-crypto/src/accumulator.rs
@@ -17,7 +17,7 @@
 //! Dynamic Cryptographic Accumulators
 
 use crate::eclair::alloc::{mode::Derived, Allocate, Allocator, Constant, Variable};
-use core::marker::PhantomData;
+use core::{fmt::Debug, hash::Hash};
 
 /// Accumulator Membership Model Types
 pub trait Types {
@@ -31,6 +31,33 @@ pub trait Types {
     type Output;
 }
 
+impl<T> Types for &T
+where
+    T: Types + ?Sized,
+{
+    type Item = T::Item;
+    type Witness = T::Witness;
+    type Output = T::Output;
+}
+
+impl<T> Types for &mut T
+where
+    T: Types + ?Sized,
+{
+    type Item = T::Item;
+    type Witness = T::Witness;
+    type Output = T::Output;
+}
+
+/// Accumulator Item Type
+pub type Item<T> = <T as Types>::Item;
+
+/// Accumulator Witness Type
+pub type Witness<T> = <T as Types>::Witness;
+
+/// Accumulator Output Type
+pub type Output<T> = <T as Types>::Output;
+
 /// Accumulator Membership Model
 pub trait Model<COM = ()>: Types {
     /// Verification Type
@@ -80,19 +107,10 @@ pub trait AssertValidVerification<COM = ()>: Model<COM> {
     );
 }
 
-/// Accumulator Witness Type
-pub type Witness<A> = <<A as Accumulator>::Model as Types>::Witness;
-
-/// Accumulator Output Type
-pub type Output<A> = <<A as Accumulator>::Model as Types>::Output;
-
 /// Accumulator
-pub trait Accumulator {
-    /// Item Type
-    type Item: ?Sized;
-
+pub trait Accumulator: Types {
     /// Model Type
-    type Model: Model<Item = Self::Item> + ?Sized;
+    type Model: Model<Item = Self::Item, Witness = Self::Witness, Output = Self::Output> + ?Sized;
 
     /// Returns the model associated with `self`.
     fn model(&self) -> &Self::Model;
@@ -102,15 +120,6 @@ pub trait Accumulator {
     /// `false` if the maximum capacity of the accumulator would be exceeded by inserting `item`.
     fn insert(&mut self, item: &Self::Item) -> bool;
 
-    /// Returns `true` whenever `fst` and `snd` can be inserted in any order into the accumulator.
-    /// This method should return `false`, the worst-case result, in the case that the insertion
-    /// order is unknown or unspecified.
-    #[inline]
-    fn are_independent(&self, fst: &Self::Item, snd: &Self::Item) -> bool {
-        let _ = (fst, snd);
-        false
-    }
-
     /// Returns a membership proof for `item` if it is contained in `self`.
     fn prove(&self, item: &Self::Item) -> Option<MembershipProof<Self::Model>>;
 
@@ -132,7 +141,6 @@ impl<A> Accumulator for &mut A
 where
     A: Accumulator + ?Sized,
 {
-    type Item = A::Item;
     type Model = A::Model;
 
     #[inline]
@@ -212,129 +220,36 @@ pub trait OptimizedAccumulator: Accumulator {
     }
 }
 
-/// Item Hash Accumulator Model
-pub struct ItemHashAccumulatorModel<T, H, A>
-where
-    H: ItemHashFunction<T>,
-    A: Accumulator<Item = H::Item>,
-{
-    /// Item Hash Function
-    item_hash_function: H,
-
-    /// Accumulator
-    accumulator: A,
-
-    /// Type Parameter Marker
-    __: PhantomData<T>,
-}
-
-impl<T, H, A> Types for ItemHashAccumulatorModel<T, H, A>
-where
-    H: ItemHashFunction<T>,
-    A: Accumulator<Item = H::Item>,
-{
-    type Item = T;
-    type Witness = Witness<A>;
-    type Output = Output<A>;
-}
-
-impl<T, H, A> Model for ItemHashAccumulatorModel<T, H, A>
-where
-    H: ItemHashFunction<T>,
-    A: Accumulator<Item = H::Item>,
-{
-    type Verification = <A::Model as Model>::Verification;
-
-    #[inline]
-    fn verify(
-        &self,
-        item: &Self::Item,
-        witness: &Self::Witness,
-        output: &Self::Output,
-        compiler: &mut (),
-    ) -> Self::Verification {
-        self.accumulator.model().verify(
-            &self.item_hash_function.item_hash(item, compiler),
-            witness,
-            output,
-            compiler,
-        )
-    }
-}
-
-/// Item Hash Accumulator
-pub struct ItemHashAccumulator<T, H, A>
-where
-    H: ItemHashFunction<T>,
-    A: Accumulator<Item = H::Item>,
-{
-    /// Item Hash Accumulator Model
-    model: ItemHashAccumulatorModel<T, H, A>,
-}
-
-impl<T, H, A> Accumulator for ItemHashAccumulator<T, H, A>
-where
-    H: ItemHashFunction<T>,
-    A: Accumulator<Item = H::Item>,
-{
-    type Item = T;
-    type Model = ItemHashAccumulatorModel<T, H, A>;
-
-    #[inline]
-    fn model(&self) -> &Self::Model {
-        &self.model
-    }
-
-    #[inline]
-    fn insert(&mut self, item: &Self::Item) -> bool {
-        self.model
-            .accumulator
-            .insert(&self.model.item_hash_function.item_hash(item, &mut ()))
-    }
-
-    #[inline]
-    fn prove(&self, item: &Self::Item) -> Option<MembershipProof<Self::Model>> {
-        self.model
-            .accumulator
-            .prove(&self.model.item_hash_function.item_hash(item, &mut ()))
-            .map(MembershipProof::into)
-    }
-
-    #[inline]
-    fn contains(&self, item: &Self::Item) -> bool {
-        self.model
-            .accumulator
-            .contains(&self.model.item_hash_function.item_hash(item, &mut ()))
-    }
-}
-
 /// Accumulator Membership Proof
-pub struct MembershipProof<M, COM = ()>
+#[derive(derivative::Derivative)]
+#[derivative(
+    Clone(bound = "M::Witness: Clone, M::Output: Clone"),
+    Copy(bound = "M::Witness: Copy, M::Output: Copy"),
+    Debug(bound = "M::Witness: Debug, M::Output: Debug"),
+    Default(bound = "M::Witness: Default, M::Output: Default"),
+    Eq(bound = "M::Witness: Eq, M::Output: Eq"),
+    Hash(bound = "M::Witness: Hash, M::Output: Hash"),
+    PartialEq(bound = "M::Witness: PartialEq, M::Output: PartialEq")
+)]
+pub struct MembershipProof<M>
 where
-    M: Model<COM> + ?Sized,
+    M: Types + ?Sized,
 {
     /// Secret Membership Witness
     witness: M::Witness,
 
     /// Accumulator Output
     output: M::Output,
-
-    /// Type Parameter Marker
-    __: PhantomData<COM>,
 }
 
-impl<M, COM> MembershipProof<M, COM>
+impl<M> MembershipProof<M>
 where
-    M: Model<COM> + ?Sized,
+    M: Types + ?Sized,
 {
     /// Builds a new [`MembershipProof`] from `witness` and `output`.
     #[inline]
     pub fn new(witness: M::Witness, output: M::Output) -> Self {
-        Self {
-            witness,
-            output,
-            __: PhantomData,
-        }
+        Self { witness, output }
     }
 
     /// Returns the accumulated output part of `self`, dropping the [`M::Witness`](Types::Witness).
@@ -351,13 +266,16 @@ where
 
     /// Verifies that `item` is stored in a known accumulator using `model`.
     #[inline]
-    pub fn verify(&self, model: &M, item: &M::Item, compiler: &mut COM) -> M::Verification {
+    pub fn verify<COM>(&self, model: &M, item: &M::Item, compiler: &mut COM) -> M::Verification
+    where
+        M: Model<COM>,
+    {
         model.verify(item, &self.witness, &self.output, compiler)
     }
 
     /// Asserts that the verification of the storage of `item` in the known accumulator is valid.
     #[inline]
-    pub fn assert_valid(&self, model: &M, item: &M::Item, compiler: &mut COM)
+    pub fn assert_valid<COM>(&self, model: &M, item: &M::Item, compiler: &mut COM)
     where
         M: AssertValidVerification<COM>,
     {
@@ -371,9 +289,9 @@ where
     /// This function cannot guarantee that the point-wise conversion of the witness and output
     /// preserves the membership proof validity.
     #[inline]
-    pub fn into<N>(self) -> MembershipProof<N, COM>
+    pub fn into<N>(self) -> MembershipProof<N>
     where
-        N: Model<COM> + ?Sized,
+        N: Types + ?Sized,
         M::Witness: Into<N::Witness>,
         M::Output: Into<N::Output>,
     {
@@ -381,9 +299,9 @@ where
     }
 }
 
-impl<M, W, O, COM> Variable<Derived<(W, O)>, COM> for MembershipProof<M, COM>
+impl<M, W, O, COM> Variable<Derived<(W, O)>, COM> for MembershipProof<M>
 where
-    M: Model<COM> + Constant<COM>,
+    M: Constant<COM> + Model<COM>,
     M::Type: Model,
     M::Witness: Variable<W, COM, Type = <M::Type as Types>::Witness>,
     M::Output: Variable<O, COM, Type = <M::Type as Types>::Output>,
diff --git a/manta-crypto/src/algebra.rs b/manta-crypto/src/algebra.rs
index f661f4aa5..eb86ed326 100644
--- a/manta-crypto/src/algebra.rs
+++ b/manta-crypto/src/algebra.rs
@@ -27,25 +27,42 @@ use manta_util::codec::{Decode, DecodeError, Encode, Read, Write};
 #[cfg(feature = "serde")]
 use manta_util::serde::{Deserialize, Serialize};
 
-/// Ring of Scalars
-pub trait Scalar<COM = ()> {
-    /// Adds `rhs` to `self` in the ring.
+/// Group
+pub trait Group<COM = ()> {
+    /// Adds `rhs` to `self` in the group.
     fn add(&self, rhs: &Self, compiler: &mut COM) -> Self;
+}
 
+/// Ring
+pub trait Ring<COM = ()>: Group<COM> {
     /// Multiplies `self` by `rhs` in the ring.
     fn mul(&self, rhs: &Self, compiler: &mut COM) -> Self;
 }
 
-/// Group
-pub trait Group<COM = ()> {
-    /// Ring of Scalars
-    type Scalar: Scalar<COM>;
-
-    /// Adds `rhs` to `self` in the group.
-    fn add(&self, rhs: &Self, compiler: &mut COM) -> Self;
+/// Scalar Multiplication
+pub trait ScalarMul<S, COM = ()> {
+    /// Output Type
+    type Output;
 
     /// Multiplies `self` by `scalar` in the group.
-    fn mul(&self, scalar: &Self::Scalar, compiler: &mut COM) -> Self;
+    fn scalar_mul(&self, scalar: &S, compiler: &mut COM) -> Self::Output;
+}
+
+/// Group with a Scalar Multiplication
+pub trait ScalarMulGroup<S, COM = ()>: Group<COM> + ScalarMul<S, COM> {}
+
+impl<G, S, COM> ScalarMulGroup<S, COM> for G where G: Group<COM> + ScalarMul<S, COM> {}
+
+/// Group Generator
+pub trait HasGenerator<G, COM = ()>
+where
+    G: Group<COM>,
+{
+    /// Generator Type
+    type Generator;
+
+    /// Returns a generator of `G`.
+    fn generator(&self) -> &Self::Generator;
 }
 
 /// Diffie-Hellman Key Agreement Scheme
@@ -56,18 +73,18 @@ pub trait Group<COM = ()> {
 )]
 #[derive(derivative::Derivative)]
 #[derivative(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
-pub struct DiffieHellman<G, COM = ()> {
+pub struct DiffieHellman<S, G, GEN = G> {
     /// Group Generator
-    pub generator: G,
+    pub generator: GEN,
 
     /// Type Parameter Marker
-    __: PhantomData<COM>,
+    __: PhantomData<(S, G)>,
 }
 
-impl<G, COM> DiffieHellman<G, COM> {
+impl<S, G, GEN> DiffieHellman<S, G, GEN> {
     /// Builds a new [`DiffieHellman`] key agreement scheme from the given `generator`.
     #[inline]
-    pub fn new(generator: G) -> Self {
+    pub fn new(generator: GEN) -> Self {
         Self {
             generator,
             __: PhantomData,
@@ -76,45 +93,56 @@ impl<G, COM> DiffieHellman<G, COM> {
 
     /// Converts `self` into the group generator.
     #[inline]
-    pub fn into_inner(self) -> G {
+    pub fn into_inner(self) -> GEN {
         self.generator
     }
 }
 
-impl<G, COM> Constant<COM> for DiffieHellman<G, COM>
+impl<S, G, GEN, COM> HasGenerator<G, COM> for DiffieHellman<S, G, GEN>
 where
-    G: Constant<COM>,
+    G: Group<COM>,
 {
-    type Type = DiffieHellman<G::Type>;
+    type Generator = GEN;
 
     #[inline]
-    fn new_constant(value: &Self::Type, compiler: &mut COM) -> Self {
-        Self::new(G::new_constant(&value.generator, compiler))
+    fn generator(&self) -> &Self::Generator {
+        &self.generator
     }
 }
 
-impl<G, COM> key::agreement::Types for DiffieHellman<G, COM>
+impl<S, G, GEN, COM> Constant<COM> for DiffieHellman<S, G, GEN>
 where
-    G: Group<COM> + security::ComputationalDiffieHellmanHardness,
+    S: Constant<COM>,
+    G: Constant<COM>,
+    GEN: Constant<COM>,
 {
-    type SecretKey = G::Scalar;
+    type Type = DiffieHellman<S::Type, G::Type, GEN::Type>;
+
+    #[inline]
+    fn new_constant(value: &Self::Type, compiler: &mut COM) -> Self {
+        Self::new(Constant::new_constant(&value.generator, compiler))
+    }
+}
+
+impl<S, G, GEN> key::agreement::Types for DiffieHellman<S, G, GEN> {
+    type SecretKey = S;
     type PublicKey = G;
     type SharedSecret = G;
 }
 
-impl<G, COM> key::agreement::Derive<COM> for DiffieHellman<G, COM>
+impl<S, G, GEN, COM> key::agreement::Derive<COM> for DiffieHellman<S, G, GEN>
 where
-    G: Group<COM> + security::ComputationalDiffieHellmanHardness,
+    GEN: ScalarMul<S, COM, Output = G> + security::ComputationalDiffieHellmanHardness,
 {
     #[inline]
     fn derive(&self, secret_key: &Self::SecretKey, compiler: &mut COM) -> Self::PublicKey {
-        self.generator.mul(secret_key, compiler)
+        self.generator.scalar_mul(secret_key, compiler)
     }
 }
 
-impl<G, COM> key::agreement::Agree<COM> for DiffieHellman<G, COM>
+impl<S, G, GEN, COM> key::agreement::Agree<COM> for DiffieHellman<S, G, GEN>
 where
-    G: Group<COM> + security::ComputationalDiffieHellmanHardness,
+    G: ScalarMul<S, COM, Output = G> + security::ComputationalDiffieHellmanHardness,
 {
     #[inline]
     fn agree(
@@ -123,15 +151,15 @@ where
         secret_key: &Self::SecretKey,
         compiler: &mut COM,
     ) -> Self::SharedSecret {
-        public_key.mul(secret_key, compiler)
+        public_key.scalar_mul(secret_key, compiler)
     }
 }
 
-impl<G, COM> Decode for DiffieHellman<G, COM>
+impl<S, G, GEN> Decode for DiffieHellman<S, G, GEN>
 where
-    G: Decode,
+    GEN: Decode,
 {
-    type Error = G::Error;
+    type Error = GEN::Error;
 
     #[inline]
     fn decode<R>(mut reader: R) -> Result<Self, DecodeError<R::Error, Self::Error>>
@@ -142,9 +170,9 @@ where
     }
 }
 
-impl<G, COM> Encode for DiffieHellman<G, COM>
+impl<S, G, GEN> Encode for DiffieHellman<S, G, GEN>
 where
-    G: Encode,
+    GEN: Encode,
 {
     #[inline]
     fn encode<W>(&self, mut writer: W) -> Result<(), W::Error>
@@ -156,9 +184,9 @@ where
     }
 }
 
-impl<D, G> Sample<D> for DiffieHellman<G>
+impl<S, G, GEN, D> Sample<D> for DiffieHellman<S, G, GEN>
 where
-    G: Sample<D>,
+    GEN: Sample<D>,
 {
     #[inline]
     fn sample<R>(distribution: D, rng: &mut R) -> Self
@@ -172,52 +200,62 @@ where
 /// Security Assumptions
 ///
 /// The following outlines some standard security assumptions for cryptographic protocols built on
-/// [`Group`] types. These security properties can be attached to instances of [`Group`] which we
-/// assume to have these hardness properties.
+/// types that implement [`ScalarMul`] for some set of scalars. These security properties can be
+/// attached to instances of [`ScalarMul`] which we assume to have these hardness properties.
 pub mod security {
     /// Discrete Logarithm Hardness Assumption
     ///
-    /// For a [`Group`](super::Group) `G`, it should be infeasible to find a procedure `f` that
-    /// makes this function return `true`:
+    /// For a type `G`, it should be infeasible to find a procedure `f` that makes this function
+    /// return `true`:
     ///
     /// ```text
-    /// fn solve<F>(g: G, y: G, f: F) -> bool
+    /// fn solve<G, S, F>(g: G, y: S, f: F) -> bool
     /// where
-    ///     F: FnOnce(G, G) -> G::Scalar,
+    ///     G: ScalarMul<S>,
+    ///     F: FnOnce(G, G) -> S,
     /// {
-    ///     y == g.mul(f(g, y))
+    ///     y == g.scalar_mul(f(g, y))
     /// }
     /// ```
     pub trait DiscreteLogarithmHardness {}
 
     /// Computational Diffie-Hellman Hardness Assumption
     ///
-    /// For a [`Group`](super::Group) `G`, it should be infeasible to find a procedure `f` that
-    /// makes this function return `true`:
+    /// For a type `G`, it should be infeasible to find a procedure `f` that makes this function
+    /// return `true`:
     ///
     /// ```text
-    /// fn solve<F>(g: G, a: G::Scalar, b: G::Scalar, f: F) -> bool
+    /// fn solve<G, S, F>(g: G, a: S, b: S, f: F) -> bool
     /// where
+    ///     G: ScalarMul<S>,
+    ///     S: Ring,
     ///     F: FnOnce(G, G, G) -> G,
     /// {
-    ///     f(g, g.mul(a), g.mul(b)) == g.mul(a.mul(b))
+    ///     f(g, g.scalar_mul(a), g.scalar_mul(b)) == g.scalar_mul(a.mul(b))
     /// }
     /// ```
     pub trait ComputationalDiffieHellmanHardness: DiscreteLogarithmHardness {}
 
     /// Decisional Diffie-Hellman Hardness Assumption
     ///
-    /// For a [`Group`](super::Group) `G`, it should be infeasible to distinguish the probability
-    /// distributions over the following two functions when [`G::Scalar](super::Group::Scalar)
-    /// inputs are sampled uniformly from their domain (and `g` the generator is fixed):
+    /// For a type `G`, it should be infeasible to distinguish the probability distributions over
+    /// the following two functions when scalar inputs are sampled uniformly from their domain (and
+    /// `g` the generator is fixed):
     ///
     /// ```text
-    /// fn dh_triple(g: G, a: G::Scalar, b: G::Scalar) -> (G, G, G) {
-    ///     (g.mul(a), g.mul(b), g.mul(a.mul(b)))
+    /// fn dh_triple<G, S>(g: G, a: S, b: S) -> (G, G, G)
+    /// where
+    ///     G: ScalarMul<S>,
+    ///     S: Ring,
+    /// {
+    ///     (g.scalar_mul(a), g.scalar_mul(b), g.scalar_mul(a.mul(b)))
     /// }
     ///
-    /// fn random_triple(g: G, a: G::Scalar, b: G::Scalar, c: G::Scalar) -> (G, G, G) {
-    ///     (g.mul(a), g.mul(b), g.mul(c))
+    /// fn random_triple<G, S>(g: G, a: S, b: S, c: S) -> (G, G, G)
+    /// where
+    ///     G: ScalarMul<S>,
+    /// {
+    ///     (g.scalar_mul(a), g.scalar_mul(b), g.scalar_mul(c))
     /// }
     /// ```
     pub trait DecisionalDiffieHellmanHardness: ComputationalDiffieHellmanHardness {}
diff --git a/manta-crypto/src/arkworks/ff.rs b/manta-crypto/src/arkworks/ff.rs
new file mode 100644
index 000000000..e9096bbd3
--- /dev/null
+++ b/manta-crypto/src/arkworks/ff.rs
@@ -0,0 +1,118 @@
+// Copyright 2019-2022 Manta Network.
+// This file is part of manta-rs.
+//
+// manta-rs is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// manta-rs is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with manta-rs.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Arkworks Finite Field Backend
+
+use manta_util::{byte_count, into_array_unchecked};
+
+#[doc(inline)]
+pub use ark_ff::*;
+
+/// Implements a fallible conversion from `F` to `$type`.
+macro_rules! field_try_into {
+    ($($name:ident => $type:tt),* $(,)?) => {
+        $(
+            #[doc = "Tries to convert a field element `x` into an integer of type `"]
+            #[doc = stringify!($type)]
+            #[doc = "`."]
+            #[inline]
+            pub fn $name<F>(x: F) -> Option<$type>
+            where
+                F: PrimeField,
+            {
+                if x < F::from(2u8).pow([$type::BITS as u64]) {
+                    let mut bytes = x.into_repr().to_bytes_le();
+                    bytes.truncate(byte_count($type::BITS) as usize);
+                    Some($type::from_le_bytes(into_array_unchecked(bytes)))
+                } else {
+                    None
+                }
+            }
+        )*
+    };
+}
+
+field_try_into! {
+   try_into_u8 => u8,
+   try_into_u16 => u16,
+   try_into_u32 => u32,
+   try_into_u64 => u64,
+   try_into_u128 => u128,
+}
+
+/// Testing Suite
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::rand::{OsRng, Rand, RngCore, Sample};
+    use alloc::vec::Vec;
+    use core::fmt::Debug;
+
+    /// Asserts that a single conversion of `value` specified by `convert` is correct.
+    #[inline]
+    pub fn assert_valid_integer_conversion<F, T, C>(convert: C, value: T)
+    where
+        F: PrimeField,
+        T: Copy + Debug + Into<F> + PartialEq,
+        C: Fn(F) -> Option<T>,
+    {
+        assert_eq!(
+            convert(value.into()),
+            Some(value),
+            "Conversion should have been the inverse of the `F::into` function."
+        );
+    }
+
+    /// Asserts that the conversions specified by `convert` are valid.
+    #[inline]
+    pub fn assert_valid_integer_conversions<F, T, C, R, const ROUNDS: usize>(
+        convert: C,
+        test_vector: Vec<T>,
+        rng: &mut R,
+    ) where
+        F: PrimeField,
+        T: Copy + Debug + Into<F> + PartialEq + Sample,
+        C: Fn(F) -> Option<T>,
+        R: RngCore + ?Sized,
+    {
+        for element in test_vector {
+            assert_valid_integer_conversion(&convert, element);
+        }
+        for _ in 0..ROUNDS {
+            assert_valid_integer_conversion(&convert, rng.gen());
+        }
+    }
+
+    /// Generates the conversion test for `$type` against the BN254 Curve.
+    macro_rules! generate_test {
+        ($name:ident, $convert:ident, $type:tt) => {
+            #[test]
+            fn $name() {
+                assert_valid_integer_conversions::<ark_bn254::Fr, _, _, _, 0xFFFF>(
+                    $convert,
+                    vec![0, 1, 2, $type::MAX - 2, $type::MAX - 1, $type::MAX],
+                    &mut OsRng,
+                );
+            }
+        };
+    }
+
+    generate_test!(u8_has_valid_conversions, try_into_u8, u8);
+    generate_test!(u16_has_valid_conversions, try_into_u16, u16);
+    generate_test!(u32_has_valid_conversions, try_into_u32, u32);
+    generate_test!(u64_has_valid_conversions, try_into_u64, u64);
+    generate_test!(u128_has_valid_conversions, try_into_u128, u128);
+}
diff --git a/manta-crypto/src/arkworks/mod.rs b/manta-crypto/src/arkworks/mod.rs
index 228994f98..454070ac3 100644
--- a/manta-crypto/src/arkworks/mod.rs
+++ b/manta-crypto/src/arkworks/mod.rs
@@ -17,12 +17,12 @@
 //! Arkworks Backend
 
 pub use ark_ec as ec;
-pub use ark_ff as ff;
 pub use ark_r1cs_std as r1cs_std;
 pub use ark_relations as relations;
 pub use ark_serialize as serialize;
 
 pub mod algebra;
 pub mod constraint;
+pub mod ff;
 pub mod pairing;
 pub mod rand;
diff --git a/manta-crypto/src/constraint.rs b/manta-crypto/src/constraint.rs
index 25f70d11c..536b4f1b7 100644
--- a/manta-crypto/src/constraint.rs
+++ b/manta-crypto/src/constraint.rs
@@ -84,12 +84,35 @@ pub trait ProofSystem {
 }
 
 /// Proof System Input
-pub trait ProofSystemInput<T>: ProofSystem
+pub trait Input<P>
+where
+    P: ProofSystem + ?Sized,
+{
+    /// Extends the `input` buffer with data from `self`.
+    fn extend(&self, input: &mut P::Input);
+}
+
+/// Proof System Input Introspection
+///
+/// This `trait` is automatically implemented for all [`T: Input<Self>`](Input) and cannot be
+/// implemented manually.
+pub trait HasInput<T>: ProofSystem
 where
     T: ?Sized,
 {
-    /// Extend the `input` with the `next` element.
-    fn extend(input: &mut Self::Input, next: &T);
+    /// Extends the `input` buffer with data from `value`.
+    fn extend(input: &mut Self::Input, value: &T);
+}
+
+impl<P, T> HasInput<T> for P
+where
+    P: ProofSystem + ?Sized,
+    T: Input<P> + ?Sized,
+{
+    #[inline]
+    fn extend(input: &mut Self::Input, value: &T) {
+        value.extend(input)
+    }
 }
 
 /// Constraint System Measurement
@@ -114,6 +137,8 @@ pub mod measure {
         }
     }
 
+    impl<M> Count<M> for () {}
+
     /// Constraint System Measurement
     pub trait Measure: Count<Constant> + Count<Public> + Count<Secret> {
         /// Returns the number of constraints stored in `self`.
@@ -154,6 +179,13 @@ pub mod measure {
         }
     }
 
+    impl Measure for () {
+        #[inline]
+        fn constraint_count(&self) -> usize {
+            0
+        }
+    }
+
     /// Constraint System Size Measurement
     #[cfg_attr(
         feature = "serde",
@@ -242,6 +274,29 @@ pub mod measure {
         }
     }
 
+    /// Prints the measurement of the call to `f` with the given `label`.
+    #[cfg(feature = "std")]
+    #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
+    #[inline]
+    pub fn print_measurement<D, F, T, COM>(label: D, f: F, compiler: &mut COM) -> T
+    where
+        D: Display,
+        F: FnOnce(&mut COM) -> T,
+        COM: Measure,
+    {
+        let before = compiler.measure();
+        let value = f(compiler);
+        println!(
+            "{}: {:?}",
+            label,
+            compiler
+                .measure()
+                .checked_sub(before)
+                .expect("Measurements should increase when adding more constraints.")
+        );
+        value
+    }
+
     /// Measurement Instrument
     pub struct Instrument<'c, COM>
     where
diff --git a/manta-crypto/src/eclair/alloc.rs b/manta-crypto/src/eclair/alloc.rs
index d2000924c..7c0129717 100644
--- a/manta-crypto/src/eclair/alloc.rs
+++ b/manta-crypto/src/eclair/alloc.rs
@@ -27,7 +27,9 @@
 //! abstractions inside of compilers, like heap allocation. Allocation only refers to lifting
 //! constants and variables from one compiler to another.
 
-use core::marker::PhantomData;
+use alloc::{boxed::Box, vec::Vec};
+use core::{iter, marker::PhantomData};
+use manta_util::{into_array_unchecked, Array, BoxArray};
 
 /// Constant Type Alias
 pub type Const<C, COM> = <C as Constant<COM>>::Type;
@@ -38,7 +40,7 @@ pub type Const<C, COM> = <C as Constant<COM>>::Type;
 /// _compilation time_. In this case, we take an explicit value of the underlying type and directly
 /// return an allocated value in the `COM` compiler. Contrast this with [`Variable`] types whose
 /// values are not known at _compilation time_ and are only known at _execution time_.
-pub trait Constant<COM>
+pub trait Constant<COM = ()>
 where
     COM: ?Sized,
 {
@@ -49,6 +51,15 @@ where
     fn new_constant(this: &Self::Type, compiler: &mut COM) -> Self;
 }
 
+impl Constant for bool {
+    type Type = bool;
+
+    #[inline]
+    fn new_constant(this: &Self::Type, _: &mut ()) -> Self {
+        *this
+    }
+}
+
 impl<COM> Constant<COM> for ()
 where
     COM: ?Sized,
@@ -74,6 +85,75 @@ where
     }
 }
 
+impl<T, const N: usize, COM> Constant<COM> for [T; N]
+where
+    COM: ?Sized,
+    T: Constant<COM>,
+{
+    type Type = [T::Type; N];
+
+    #[inline]
+    fn new_constant(this: &Self::Type, compiler: &mut COM) -> Self {
+        into_array_unchecked(
+            this.iter()
+                .map(|this| this.as_constant(compiler))
+                .collect::<Vec<_>>(),
+        )
+    }
+}
+
+impl<T, COM> Constant<COM> for Vec<T>
+where
+    COM: ?Sized,
+    T: Constant<COM>,
+{
+    type Type = Vec<T::Type>;
+
+    #[inline]
+    fn new_constant(this: &Self::Type, compiler: &mut COM) -> Self {
+        this.iter().map(|this| this.as_constant(compiler)).collect()
+    }
+}
+
+impl<T, COM> Constant<COM> for Box<[T]>
+where
+    COM: ?Sized,
+    T: Constant<COM>,
+{
+    type Type = Box<[T::Type]>;
+
+    #[inline]
+    fn new_constant(this: &Self::Type, compiler: &mut COM) -> Self {
+        this.iter().map(|this| this.as_constant(compiler)).collect()
+    }
+}
+
+impl<T, const N: usize, COM> Constant<COM> for Array<T, N>
+where
+    COM: ?Sized,
+    T: Constant<COM>,
+{
+    type Type = Array<T::Type, N>;
+
+    #[inline]
+    fn new_constant(this: &Self::Type, compiler: &mut COM) -> Self {
+        this.iter().map(|this| this.as_constant(compiler)).collect()
+    }
+}
+
+impl<T, const N: usize, COM> Constant<COM> for BoxArray<T, N>
+where
+    COM: ?Sized,
+    T: Constant<COM>,
+{
+    type Type = Array<T::Type, N>;
+
+    #[inline]
+    fn new_constant(this: &Self::Type, compiler: &mut COM) -> Self {
+        this.iter().map(|this| this.as_constant(compiler)).collect()
+    }
+}
+
 /// Variable Type Alias
 pub type Var<V, M, COM> = <V as Variable<M, COM>>::Type;
 
@@ -90,7 +170,7 @@ pub type Var<V, M, COM> = <V as Variable<M, COM>>::Type;
 /// The tag `M` in the type parameters of this trait refers to the [`Variable`]'s allocation mode.
 /// See the [`mode`] module for more details on why allocation modes are necessary and useful and
 /// how to use them.
-pub trait Variable<M, COM>
+pub trait Variable<M, COM = ()>
 where
     COM: ?Sized,
 {
@@ -144,6 +224,90 @@ where
     }
 }
 
+impl<T, M, COM> Variable<M, COM> for Box<T>
+where
+    COM: ?Sized,
+    T: Variable<M, COM>,
+{
+    type Type = Box<T::Type>;
+
+    #[inline]
+    fn new_unknown(compiler: &mut COM) -> Self {
+        Self::new(compiler.allocate_unknown())
+    }
+
+    #[inline]
+    fn new_known(this: &Self::Type, compiler: &mut COM) -> Self {
+        Self::new(T::new_known(this, compiler))
+    }
+}
+
+impl<T, const N: usize, M, COM> Variable<M, COM> for [T; N]
+where
+    COM: ?Sized,
+    T: Variable<M, COM>,
+{
+    type Type = [T::Type; N];
+
+    #[inline]
+    fn new_unknown(compiler: &mut COM) -> Self {
+        into_array_unchecked(
+            iter::repeat_with(|| compiler.allocate_unknown())
+                .take(N)
+                .collect::<Vec<_>>(),
+        )
+    }
+
+    #[inline]
+    fn new_known(this: &Self::Type, compiler: &mut COM) -> Self {
+        into_array_unchecked(
+            this.iter()
+                .map(|this| this.as_known(compiler))
+                .collect::<Vec<_>>(),
+        )
+    }
+}
+
+impl<T, const N: usize, M, COM> Variable<M, COM> for Array<T, N>
+where
+    COM: ?Sized,
+    T: Variable<M, COM>,
+{
+    type Type = Array<T::Type, N>;
+
+    #[inline]
+    fn new_unknown(compiler: &mut COM) -> Self {
+        iter::repeat_with(|| compiler.allocate_unknown())
+            .take(N)
+            .collect()
+    }
+
+    #[inline]
+    fn new_known(this: &Self::Type, compiler: &mut COM) -> Self {
+        this.iter().map(|this| this.as_known(compiler)).collect()
+    }
+}
+
+impl<T, const N: usize, M, COM> Variable<M, COM> for BoxArray<T, N>
+where
+    COM: ?Sized,
+    T: Variable<M, COM>,
+{
+    type Type = BoxArray<T::Type, N>;
+
+    #[inline]
+    fn new_unknown(compiler: &mut COM) -> Self {
+        iter::repeat_with(|| compiler.allocate_unknown())
+            .take(N)
+            .collect()
+    }
+
+    #[inline]
+    fn new_known(this: &Self::Type, compiler: &mut COM) -> Self {
+        this.iter().map(|this| this.as_known(compiler)).collect()
+    }
+}
+
 /// Allocation Auto-`trait`
 ///
 /// Allocation schemes are built up from the individual variables which can be allocated into a
@@ -153,7 +317,7 @@ where
 ///
 /// See [`Constant`] and [`Variable`] for more details on including a specific variable in the
 /// allocation scheme for a compiler.
-pub trait Allocate<COM>
+pub trait Allocate<COM = ()>
 where
     COM: ?Sized,
 {
@@ -191,7 +355,12 @@ where
     }
 }
 
-impl<COM, T> Allocate<COM> for T where T: ?Sized {}
+impl<COM, T> Allocate<COM> for T
+where
+    COM: ?Sized,
+    T: ?Sized,
+{
+}
 
 /// Allocator Auto-`trait`
 ///
diff --git a/manta-crypto/src/eclair/bool.rs b/manta-crypto/src/eclair/bool.rs
index c0050bd17..582ac9adc 100644
--- a/manta-crypto/src/eclair/bool.rs
+++ b/manta-crypto/src/eclair/bool.rs
@@ -20,10 +20,10 @@
 //! types. In this module, we define the access interfaces needed to simulate the [`bool`] type with
 //! [`Bool`].
 
-use crate::eclair::{cmp::PartialEq, Has};
+use crate::eclair::{cmp::PartialEq, Has, Type};
 
 /// Boolean Type Inside of the Compiler
-pub type Bool<COM = ()> = <COM as Has<bool>>::Type;
+pub type Bool<COM = ()> = Type<COM, bool>;
 
 /// Assertion
 pub trait Assert: Has<bool> {
@@ -42,6 +42,13 @@ pub trait Assert: Has<bool> {
     }
 }
 
+impl Assert for () {
+    #[inline]
+    fn assert(&mut self, bit: &bool) {
+        assert!(bit)
+    }
+}
+
 /// Equality Assertion
 pub trait AssertEq: Assert {
     /// Asserts that `lhs` and `rhs` are equal.
@@ -91,6 +98,26 @@ where
     fn select(bit: &Bool<COM>, true_value: &Self, false_value: &Self, compiler: &mut COM) -> Self;
 }
 
+/// Implements [`ConditionalSelect`] for the given `$type`.
+macro_rules! impl_conditional_select {
+    ($($type:tt),* $(,)?) => {
+        $(
+            impl ConditionalSelect for $type {
+                #[inline]
+                fn select(bit: &Bool, true_value: &Self, false_value: &Self, _: &mut ()) -> Self {
+                    if *bit {
+                        true_value.clone()
+                    } else {
+                        false_value.clone()
+                    }
+                }
+            }
+        )*
+    }
+}
+
+impl_conditional_select!(bool, u8, u16, u32, u64, u128, i8, i16, i32, i64, i128);
+
 /// Conditional Swap
 pub trait ConditionalSwap<COM = ()>: Sized
 where
diff --git a/manta-crypto/src/eclair/cmp.rs b/manta-crypto/src/eclair/cmp.rs
index 66ece418d..31aeae3c8 100644
--- a/manta-crypto/src/eclair/cmp.rs
+++ b/manta-crypto/src/eclair/cmp.rs
@@ -17,10 +17,14 @@
 //! Comparison
 
 use crate::eclair::{
-    bool::{Assert, Bool},
-    ops::Not,
+    alloc::{Allocate, Constant},
+    bool::{Assert, AssertEq, Bool},
+    ops::{BitAnd, Not},
     Has,
 };
+use alloc::{boxed::Box, vec::Vec};
+use core::cmp;
+use manta_util::{Array, BoxArray};
 
 /// Partial Equivalence Relations
 pub trait PartialEq<Rhs, COM = ()>
@@ -56,22 +60,151 @@ where
     }
 }
 
-/* TODO:
-impl<T, Rhs> PartialEq<Rhs> for T
+/// Implements [`PartialEq`] for the given `$type`.
+macro_rules! impl_partial_eq {
+    ($($type:tt),* $(,)?) => {
+        $(
+            impl<Rhs> PartialEq<Rhs> for $type
+            where
+                $type: cmp::PartialEq<Rhs>,
+            {
+                #[inline]
+                fn eq(&self, rhs: &Rhs, _: &mut ()) -> bool {
+                    cmp::PartialEq::eq(self, rhs)
+                }
+
+                #[inline]
+                fn ne(&self, rhs: &Rhs, _: &mut ()) -> bool {
+                    cmp::PartialEq::ne(self, rhs)
+                }
+            }
+        )*
+    };
+}
+
+impl_partial_eq!(bool, u8, u16, u32, u64, u128, i8, i16, i32, i64, i128);
+
+impl<T, Rhs, COM> PartialEq<Vec<Rhs>, COM> for Vec<T>
+where
+    COM: Has<bool>,
+    Bool<COM>: Constant<COM, Type = bool> + BitAnd<Bool<COM>, COM, Output = Bool<COM>>,
+    T: PartialEq<Rhs, COM>,
+{
+    #[inline]
+    fn eq(&self, rhs: &Vec<Rhs>, compiler: &mut COM) -> Bool<COM> {
+        if self.len() != rhs.len() {
+            false.as_constant(compiler)
+        } else {
+            let mut are_equal = true.as_constant::<Bool<COM>>(compiler);
+            for (lhs, rhs) in self.iter().zip(rhs) {
+                are_equal = are_equal.bitand(lhs.eq(rhs, compiler), compiler);
+            }
+            are_equal
+        }
+    }
+
+    #[inline]
+    fn assert_equal(&self, rhs: &Vec<Rhs>, compiler: &mut COM)
+    where
+        COM: Assert,
+    {
+        if self.len() != rhs.len() {
+            let not_equal = false.as_constant(compiler);
+            compiler.assert(&not_equal);
+        } else {
+            for (lhs, rhs) in self.iter().zip(rhs) {
+                compiler.assert_eq(lhs, rhs);
+            }
+        }
+    }
+}
+
+impl<T, Rhs, COM> PartialEq<Box<[Rhs]>, COM> for Box<[T]>
+where
+    COM: Has<bool>,
+    Bool<COM>: Constant<COM, Type = bool> + BitAnd<Bool<COM>, COM, Output = Bool<COM>>,
+    T: PartialEq<Rhs, COM>,
+{
+    #[inline]
+    fn eq(&self, rhs: &Box<[Rhs]>, compiler: &mut COM) -> Bool<COM> {
+        if self.len() != rhs.len() {
+            false.as_constant(compiler)
+        } else {
+            let mut are_equal = true.as_constant::<Bool<COM>>(compiler);
+            for (lhs, rhs) in self.iter().zip(rhs.iter()) {
+                are_equal = are_equal.bitand(lhs.eq(rhs, compiler), compiler);
+            }
+            are_equal
+        }
+    }
+
+    #[inline]
+    fn assert_equal(&self, rhs: &Box<[Rhs]>, compiler: &mut COM)
+    where
+        COM: Assert,
+    {
+        if self.len() != rhs.len() {
+            let not_equal = false.as_constant(compiler);
+            compiler.assert(&not_equal);
+        } else {
+            for (lhs, rhs) in self.iter().zip(rhs.iter()) {
+                compiler.assert_eq(lhs, rhs);
+            }
+        }
+    }
+}
+
+impl<T, Rhs, const N: usize, COM> PartialEq<Array<Rhs, N>, COM> for Array<T, N>
+where
+    COM: Has<bool>,
+    Bool<COM>: Constant<COM, Type = bool> + BitAnd<Bool<COM>, COM, Output = Bool<COM>>,
+    T: PartialEq<Rhs, COM>,
+{
+    #[inline]
+    fn eq(&self, rhs: &Array<Rhs, N>, compiler: &mut COM) -> Bool<COM> {
+        let mut are_equal = true.as_constant::<Bool<COM>>(compiler);
+        for (lhs, rhs) in self.iter().zip(rhs) {
+            are_equal = are_equal.bitand(lhs.eq(rhs, compiler), compiler);
+        }
+        are_equal
+    }
+
+    #[inline]
+    fn assert_equal(&self, rhs: &Array<Rhs, N>, compiler: &mut COM)
+    where
+        COM: Assert,
+    {
+        for (lhs, rhs) in self.iter().zip(rhs) {
+            compiler.assert_eq(lhs, rhs);
+        }
+    }
+}
+
+impl<T, Rhs, const N: usize, COM> PartialEq<BoxArray<Rhs, N>, COM> for BoxArray<T, N>
 where
-    T: cmp::PartialEq<Rhs>,
+    COM: Has<bool>,
+    Bool<COM>: Constant<COM, Type = bool> + BitAnd<Bool<COM>, COM, Output = Bool<COM>>,
+    T: PartialEq<Rhs, COM>,
 {
     #[inline]
-    fn eq(&self, rhs: &Rhs, _: &mut ()) -> bool {
-        self.eq(rhs)
+    fn eq(&self, rhs: &BoxArray<Rhs, N>, compiler: &mut COM) -> Bool<COM> {
+        let mut are_equal = true.as_constant::<Bool<COM>>(compiler);
+        for (lhs, rhs) in self.iter().zip(rhs) {
+            are_equal = are_equal.bitand(lhs.eq(rhs, compiler), compiler);
+        }
+        are_equal
     }
 
     #[inline]
-    fn ne(&self, rhs: &Rhs, _: &mut ()) -> bool {
-        self.ne(rhs)
+    fn assert_equal(&self, rhs: &BoxArray<Rhs, N>, compiler: &mut COM)
+    where
+        COM: Assert,
+    {
+        for (lhs, rhs) in self.iter().zip(rhs) {
+            compiler.assert_eq(lhs, rhs);
+        }
     }
 }
-*/
 
 /// Equality
 pub trait Eq<COM = ()>: PartialEq<Self, COM>
@@ -79,7 +212,3 @@ where
     COM: Has<bool>,
 {
 }
-
-/* TODO:
-impl<T> Eq for T where T: cmp::Eq {}
-*/
diff --git a/manta-crypto/src/eclair/mod.rs b/manta-crypto/src/eclair/mod.rs
index bdbc2c2d7..db9df8ab9 100644
--- a/manta-crypto/src/eclair/mod.rs
+++ b/manta-crypto/src/eclair/mod.rs
@@ -46,6 +46,22 @@ impl Native for () {
 /// This `trait` is explicitly not implemented for `()`, the default native compiler. This marker
 /// can be used to write explicitly different implementations for native and non-native compilers
 /// where otherwise a generic implementation would have to exist.
+///
+/// # Limitations
+///
+/// This is an emulation of an unimplemented feature of rust called ["negative trait bounds"]. As it
+/// currently stands, the compiler will make instances of [`NonNative`] outside of the ECLAIR crate
+/// unusable as you'll run into [error 0119] which has the following notice:
+///
+/// ```text
+/// note: upstream crates may add a new impl of trait `NonNative` for type `()` in future versions
+/// ```
+///
+/// Even though this trait will never be implemented for `()`, there's no way the Rust compiler can
+/// know this. As of right now, we can only use this `trait` internally to this crate.
+///
+/// ["negative trait bounds"]: https://doc.rust-lang.org/beta/unstable-book/language-features/negative-impls.html
+/// [error 0119]: https://doc.rust-lang.org/error-index.html#E0119
 pub trait NonNative {}
 
 /// Compiler Type Introspection
@@ -67,3 +83,6 @@ pub trait Has<T> {
 impl<T> Has<T> for () {
     type Type = T;
 }
+
+/// Compiler Introspected Type
+pub type Type<COM, T> = <COM as Has<T>>::Type;
diff --git a/manta-crypto/src/eclair/num.rs b/manta-crypto/src/eclair/num.rs
index 507bec67f..5e04426a7 100644
--- a/manta-crypto/src/eclair/num.rs
+++ b/manta-crypto/src/eclair/num.rs
@@ -16,7 +16,13 @@
 
 //! Numeric Types and Traits
 
-use crate::eclair::ops::{Add, AddAssign, Mul, MulAssign};
+use crate::eclair::{
+    alloc::{Allocator, Variable},
+    bool::{Assert, Bool, ConditionalSelect, ConditionalSwap},
+    cmp::PartialEq,
+    ops::{Add, AddAssign, Mul, MulAssign, Not},
+    Has,
+};
 use core::{borrow::Borrow, ops::Deref};
 
 /// Additive Identity
@@ -24,22 +30,99 @@ pub trait Zero<COM = ()> {
     /// Verification Type
     type Verification;
 
+    /// Returns the additive identity for `Self`.
+    fn zero(compiler: &mut COM) -> Self;
+
     /// Returns a truthy value if `self` is equal to the additive identity.
     fn is_zero(&self, compiler: &mut COM) -> Self::Verification;
 }
 
+impl Zero for bool {
+    type Verification = bool;
+
+    #[inline]
+    fn zero(_: &mut ()) -> Self {
+        false
+    }
+
+    #[inline]
+    fn is_zero(&self, _: &mut ()) -> Self::Verification {
+        !(*self)
+    }
+}
+
 /// Multiplicative Identity
 pub trait One<COM = ()> {
     /// Verification Type
     type Verification;
 
+    /// Returns the multiplicative identity for `Self`.
+    fn one(compiler: &mut COM) -> Self;
+
     /// Returns a truthy value if `self` is equal to the multiplicative identity.
     fn is_one(&self, compiler: &mut COM) -> Self::Verification;
 }
 
+impl One for bool {
+    type Verification = bool;
+
+    #[inline]
+    fn one(_: &mut ()) -> Self {
+        true
+    }
+
+    #[inline]
+    fn is_one(&self, _: &mut ()) -> Self::Verification {
+        *self
+    }
+}
+
+/// Defines an implementation for [`Zero`] and [`One`] for integers.
+macro_rules! define_zero_one {
+    ($($type:tt),* $(,)?) => {
+        $(
+            impl Zero for $type {
+                type Verification = bool;
+
+                #[inline]
+                fn zero(_: &mut ()) -> Self {
+                    0
+                }
+
+                #[inline]
+                fn is_zero(&self, compiler: &mut ()) -> Self::Verification {
+                    *self == Self::zero(compiler)
+                }
+            }
+
+            impl One for $type {
+                type Verification = bool;
+
+                #[inline]
+                fn one(_: &mut ()) -> Self {
+                    1
+                }
+
+                #[inline]
+                fn is_one(&self, compiler: &mut ()) -> Self::Verification {
+                    *self == Self::one(compiler)
+                }
+            }
+        )*
+    }
+}
+
+define_zero_one!(u8, u16, u32, u64, u128, i8, i16, i32, i64, i128);
+
 /// Within-Bit-Range Assertion
+///
+/// # Restrictions
+///
+/// This `trait` assumes that `BITS > 0` and does not currently support `BITS = 0`. In this case
+/// we would have an assertion that `x < 2^0 = 1` which is just that `x = 0` in most systems. For
+/// this usecase, the [`Zero`] `trait` should be considered instead.
 pub trait AssertWithinBitRange<T, const BITS: usize> {
-    /// Asserts that `value` is smaller than `2^BITS`
+    /// Asserts that `value` is smaller than `2^BITS`.
     fn assert_within_range(&mut self, value: &T);
 }
 
@@ -180,6 +263,90 @@ where
     }
 }
 
+impl<T, const BITS: usize, COM> Zero<COM> for UnsignedInteger<T, BITS>
+where
+    T: Zero<COM>,
+{
+    type Verification = T::Verification;
+
+    #[inline]
+    fn zero(compiler: &mut COM) -> Self {
+        Self::new_unchecked(T::zero(compiler))
+    }
+
+    #[inline]
+    fn is_zero(&self, compiler: &mut COM) -> Self::Verification {
+        self.0.is_zero(compiler)
+    }
+}
+
+impl<T, const BITS: usize, COM> One<COM> for UnsignedInteger<T, BITS>
+where
+    T: One<COM>,
+{
+    type Verification = T::Verification;
+
+    #[inline]
+    fn one(compiler: &mut COM) -> Self {
+        Self::new_unchecked(T::one(compiler))
+    }
+
+    #[inline]
+    fn is_one(&self, compiler: &mut COM) -> Self::Verification {
+        self.0.is_one(compiler)
+    }
+}
+
+impl<T, const BITS: usize, COM> PartialEq<Self, COM> for UnsignedInteger<T, BITS>
+where
+    COM: Has<bool>,
+    T: PartialEq<T, COM>,
+{
+    #[inline]
+    fn eq(&self, rhs: &Self, compiler: &mut COM) -> Bool<COM> {
+        self.0.eq(&rhs.0, compiler)
+    }
+
+    #[inline]
+    fn ne(&self, rhs: &Self, compiler: &mut COM) -> Bool<COM>
+    where
+        Bool<COM>: Not<COM, Output = Bool<COM>>,
+    {
+        self.0.ne(&rhs.0, compiler)
+    }
+
+    #[inline]
+    fn assert_equal(&self, rhs: &Self, compiler: &mut COM)
+    where
+        COM: Assert,
+    {
+        self.0.assert_equal(&rhs.0, compiler)
+    }
+}
+
+impl<T, const BITS: usize, COM> ConditionalSelect<COM> for UnsignedInteger<T, BITS>
+where
+    COM: Has<bool>,
+    T: ConditionalSelect<COM>,
+{
+    #[inline]
+    fn select(bit: &Bool<COM>, true_value: &Self, false_value: &Self, compiler: &mut COM) -> Self {
+        Self::new_unchecked(T::select(bit, &true_value.0, &false_value.0, compiler))
+    }
+}
+
+impl<T, const BITS: usize, COM> ConditionalSwap<COM> for UnsignedInteger<T, BITS>
+where
+    COM: Has<bool>,
+    T: ConditionalSwap<COM>,
+{
+    #[inline]
+    fn swap(bit: &Bool<COM>, lhs: &Self, rhs: &Self, compiler: &mut COM) -> (Self, Self) {
+        let (lhs, rhs) = T::swap(bit, &lhs.0, &rhs.0, compiler);
+        (Self::new_unchecked(lhs), Self::new_unchecked(rhs))
+    }
+}
+
 /// Defines [`UnsignedInteger`] types for the given number of `$bits`.
 macro_rules! define_uint {
     ($($name:ident, $bits:expr),* $(,)?) => {
@@ -202,3 +369,32 @@ define_uint!(
     U190, 190, U200, 200, U210, 210, U220, 220, U230, 230, U240, 240, U250, 250, U251, 251, U252,
     252, U253, 253, U254, 254, U255, 255, U256, 256,
 );
+
+/// Defines [`Variable`] allocation implementation for [`UnsignedInteger`] whenever it has a native
+/// Rust counterpart.
+macro_rules! define_uint_allocation {
+    ($($type:tt, $bits:expr),* $(,)?) => {
+        $(
+            impl<T, M, COM> Variable<M, COM> for UnsignedInteger<T, $bits>
+            where
+                COM: AssertWithinBitRange<T, $bits>,
+                T: Variable<M, COM>,
+                T::Type: From<$type>,
+            {
+                type Type = $type;
+
+                #[inline]
+                fn new_unknown(compiler: &mut COM) -> Self {
+                    Self::new(compiler.allocate_unknown(), compiler)
+                }
+
+                #[inline]
+                fn new_known(this: &Self::Type, compiler: &mut COM) -> Self {
+                    Self::new(compiler.allocate_known(&(*this).into()), compiler)
+                }
+            }
+        )*
+    };
+}
+
+define_uint_allocation!(u8, 8, u16, 16, u32, 32, u64, 64, u128, 128);
diff --git a/manta-crypto/src/encryption/hybrid.rs b/manta-crypto/src/encryption/hybrid.rs
index a6308fd69..1141f794a 100644
--- a/manta-crypto/src/encryption/hybrid.rs
+++ b/manta-crypto/src/encryption/hybrid.rs
@@ -21,9 +21,13 @@
 //! encryption scheme inlines this complexity into the encryption interfaces.
 
 use crate::{
+    constraint::{HasInput, Input},
     eclair::{
         self,
-        alloc::{mode::Derived, Allocate, Allocator, Constant, Var, Variable},
+        alloc::{
+            mode::{Derived, Public, Secret},
+            Allocate, Allocator, Constant, Var, Variable,
+        },
         bool::{Assert, AssertEq, Bool},
         ops::BitAnd,
         Has,
@@ -118,6 +122,28 @@ where
     }
 }
 
+impl<K, E, COM> Variable<Secret, COM> for Randomness<K, E>
+where
+    K: key::agreement::Types + Constant<COM>,
+    E: Constant<COM> + RandomnessType,
+    K::SecretKey: Variable<Secret, COM>,
+    E::Randomness: Variable<Secret, COM>,
+    K::Type: key::agreement::Types<SecretKey = Var<K::SecretKey, Secret, COM>>,
+    E::Type: RandomnessType<Randomness = Var<E::Randomness, Secret, COM>>,
+{
+    type Type = Randomness<K::Type, E::Type>;
+
+    #[inline]
+    fn new_unknown(compiler: &mut COM) -> Self {
+        Variable::<Derived<(Secret, Secret)>, COM>::new_unknown(compiler)
+    }
+
+    #[inline]
+    fn new_known(this: &Self::Type, compiler: &mut COM) -> Self {
+        Variable::<Derived<(Secret, Secret)>, COM>::new_known(this, compiler)
+    }
+}
+
 impl<K, E, S, R, COM> Variable<Derived<(S, R)>, COM> for Randomness<K, E>
 where
     K: key::agreement::Types + Constant<COM>,
@@ -228,6 +254,28 @@ where
     }
 }
 
+impl<K, E, COM> Variable<Public, COM> for Ciphertext<K, E>
+where
+    K: key::agreement::Types + Constant<COM>,
+    E: CiphertextType + Constant<COM>,
+    K::PublicKey: Variable<Public, COM>,
+    E::Ciphertext: Variable<Public, COM>,
+    K::Type: key::agreement::Types<PublicKey = Var<K::PublicKey, Public, COM>>,
+    E::Type: CiphertextType<Ciphertext = Var<E::Ciphertext, Public, COM>>,
+{
+    type Type = Ciphertext<K::Type, E::Type>;
+
+    #[inline]
+    fn new_unknown(compiler: &mut COM) -> Self {
+        Variable::<Derived<(Public, Public)>, COM>::new_unknown(compiler)
+    }
+
+    #[inline]
+    fn new_known(this: &Self::Type, compiler: &mut COM) -> Self {
+        Variable::<Derived<(Public, Public)>, COM>::new_known(this, compiler)
+    }
+}
+
 impl<K, E, P, C, COM> Variable<Derived<(P, C)>, COM> for Ciphertext<K, E>
 where
     K: key::agreement::Types + Constant<COM>,
@@ -253,6 +301,37 @@ where
     }
 }
 
+impl<K, E> Encode for Ciphertext<K, E>
+where
+    K: key::agreement::Types,
+    K::PublicKey: Encode,
+    E: CiphertextType,
+    E::Ciphertext: Encode,
+{
+    #[inline]
+    fn encode<W>(&self, mut writer: W) -> Result<(), W::Error>
+    where
+        W: Write,
+    {
+        self.ephemeral_public_key.encode(&mut writer)?;
+        self.ciphertext.encode(&mut writer)?;
+        Ok(())
+    }
+}
+
+impl<K, E, P> Input<P> for Ciphertext<K, E>
+where
+    K: key::agreement::Types,
+    E: CiphertextType,
+    P: HasInput<K::PublicKey> + HasInput<E::Ciphertext> + ?Sized,
+{
+    #[inline]
+    fn extend(&self, input: &mut P::Input) {
+        P::extend(input, &self.ephemeral_public_key);
+        P::extend(input, &self.ciphertext);
+    }
+}
+
 /// Hybrid Encryption Scheme
 #[cfg_attr(
     feature = "serde",
diff --git a/manta-crypto/src/encryption/mod.rs b/manta-crypto/src/encryption/mod.rs
index 5e4a5039b..0eafb300b 100644
--- a/manta-crypto/src/encryption/mod.rs
+++ b/manta-crypto/src/encryption/mod.rs
@@ -21,6 +21,7 @@
 //! [`Decrypt`] `trait`s for more.
 
 use crate::{
+    constraint::{HasInput, Input, ProofSystem},
     eclair::{
         self,
         alloc::{
@@ -33,7 +34,8 @@ use crate::{
     },
     rand::{Rand, RngCore, Sample},
 };
-use core::{fmt::Debug, hash::Hash};
+use core::{fmt::Debug, hash::Hash, marker::PhantomData};
+use manta_util::codec::{Encode, Write};
 
 #[cfg(feature = "serde")]
 use manta_util::serde::{Deserialize, Serialize};
@@ -67,6 +69,81 @@ where
 /// Header Type
 pub type Header<T> = <T as HeaderType>::Header;
 
+/// Empty Header
+#[derive(derivative::Derivative)]
+#[derivative(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct EmptyHeader<COM = ()>(PhantomData<COM>);
+
+impl<COM> Constant<COM> for EmptyHeader<COM> {
+    type Type = EmptyHeader;
+
+    #[inline]
+    fn new_constant(this: &Self::Type, compiler: &mut COM) -> Self {
+        let _ = (this, compiler);
+        Self::default()
+    }
+}
+
+impl<M, COM> Variable<M, COM> for EmptyHeader<COM> {
+    type Type = EmptyHeader;
+
+    #[inline]
+    fn new_unknown(compiler: &mut COM) -> Self {
+        let _ = compiler;
+        Self::default()
+    }
+
+    #[inline]
+    fn new_known(this: &Self::Type, compiler: &mut COM) -> Self {
+        let _ = (this, compiler);
+        Self::default()
+    }
+}
+
+impl<COM> eclair::cmp::PartialEq<Self, COM> for EmptyHeader<COM>
+where
+    COM: Has<bool>,
+    Bool<COM>: Constant<COM, Type = bool>,
+{
+    #[inline]
+    fn eq(&self, rhs: &Self, compiler: &mut COM) -> Bool<COM> {
+        let _ = rhs;
+        Bool::<COM>::new_constant(&true, compiler)
+    }
+
+    #[inline]
+    fn ne(&self, rhs: &Self, compiler: &mut COM) -> Bool<COM> {
+        let _ = rhs;
+        Bool::<COM>::new_constant(&false, compiler)
+    }
+
+    #[inline]
+    fn assert_equal(&self, rhs: &Self, compiler: &mut COM) {
+        let _ = (rhs, compiler);
+    }
+}
+
+impl Encode for EmptyHeader {
+    #[inline]
+    fn encode<W>(&self, writer: W) -> Result<(), W::Error>
+    where
+        W: Write,
+    {
+        let _ = writer;
+        Ok(())
+    }
+}
+
+impl<P> Input<P> for EmptyHeader
+where
+    P: ProofSystem + ?Sized,
+{
+    #[inline]
+    fn extend(&self, input: &mut P::Input) {
+        let _ = input;
+    }
+}
+
 /// Ciphertext
 ///
 /// The ciphertext type represents the piece of the encrypt-decrypt interface that contains the
@@ -526,21 +603,6 @@ where
 {
 }
 
-impl<E, H, C> Sample<(H, C)> for EncryptedMessage<E>
-where
-    E: CiphertextType + HeaderType,
-    E::Header: Sample<H>,
-    E::Ciphertext: Sample<C>,
-{
-    #[inline]
-    fn sample<R>(distribution: (H, C), rng: &mut R) -> Self
-    where
-        R: RngCore + ?Sized,
-    {
-        Self::new(rng.sample(distribution.0), rng.sample(distribution.1))
-    }
-}
-
 impl<E, H, C, COM> Variable<Derived<(H, C)>, COM> for EncryptedMessage<E>
 where
     E: CiphertextType + HeaderType + Constant<COM>,
@@ -577,15 +639,56 @@ where
 
     #[inline]
     fn new_unknown(compiler: &mut COM) -> Self {
-        Self::new(compiler.allocate_unknown(), compiler.allocate_unknown())
+        Variable::<Derived<(Public, Public)>, _>::new_unknown(compiler)
     }
 
     #[inline]
     fn new_known(this: &Self::Type, compiler: &mut COM) -> Self {
-        Self::new(
-            this.header.as_known(compiler),
-            this.ciphertext.as_known(compiler),
-        )
+        Variable::<Derived<(Public, Public)>, _>::new_known(this, compiler)
+    }
+}
+
+impl<E, H, C> Sample<(H, C)> for EncryptedMessage<E>
+where
+    E: CiphertextType + HeaderType,
+    E::Header: Sample<H>,
+    E::Ciphertext: Sample<C>,
+{
+    #[inline]
+    fn sample<R>(distribution: (H, C), rng: &mut R) -> Self
+    where
+        R: RngCore + ?Sized,
+    {
+        Self::new(rng.sample(distribution.0), rng.sample(distribution.1))
+    }
+}
+
+impl<E> Encode for EncryptedMessage<E>
+where
+    E: CiphertextType + HeaderType,
+    E::Header: Encode,
+    E::Ciphertext: Encode,
+{
+    #[inline]
+    fn encode<W>(&self, mut writer: W) -> Result<(), W::Error>
+    where
+        W: Write,
+    {
+        self.header.encode(&mut writer)?;
+        self.ciphertext.encode(&mut writer)?;
+        Ok(())
+    }
+}
+
+impl<E, P> Input<P> for EncryptedMessage<E>
+where
+    E: CiphertextType + HeaderType,
+    P: HasInput<E::Header> + HasInput<E::Ciphertext> + ?Sized,
+{
+    #[inline]
+    fn extend(&self, input: &mut P::Input) {
+        P::extend(input, &self.header);
+        P::extend(input, &self.ciphertext);
     }
 }
 
diff --git a/manta-crypto/src/key.rs b/manta-crypto/src/key.rs
index 0eb147c63..288d85cdc 100644
--- a/manta-crypto/src/key.rs
+++ b/manta-crypto/src/key.rs
@@ -117,9 +117,11 @@ pub mod agreement {
 /// Key Derivation Functions
 pub mod kdf {
     use crate::rand::{RngCore, Sample};
-    use alloc::vec::Vec;
     use core::marker::PhantomData;
-    use manta_util::codec::{Decode, DecodeError, Encode, Read, Write};
+    use manta_util::{
+        codec::{Decode, DecodeError, Encode, Read, Write},
+        AsBytes,
+    };
 
     #[cfg(feature = "serde")]
     use manta_util::serde::{Deserialize, Serialize};
@@ -175,12 +177,6 @@ pub mod kdf {
         }
     }
 
-    /// Byte Conversion Trait
-    pub trait AsBytes {
-        /// Returns an owned byte representation of `self`.
-        fn as_bytes(&self) -> Vec<u8>;
-    }
-
     /// From Byte Vector Adapter
     #[cfg_attr(
         feature = "serde",
diff --git a/manta-crypto/src/merkle_tree/forest.rs b/manta-crypto/src/merkle_tree/forest.rs
index de2d946b5..975dce3b0 100644
--- a/manta-crypto/src/merkle_tree/forest.rs
+++ b/manta-crypto/src/merkle_tree/forest.rs
@@ -24,13 +24,14 @@
 
 use crate::{
     accumulator::{
-        Accumulator, ConstantCapacityAccumulator, ExactSizeAccumulator, MembershipProof,
+        self, Accumulator, ConstantCapacityAccumulator, ExactSizeAccumulator, MembershipProof,
         OptimizedAccumulator,
     },
     merkle_tree::{
         fork::ForkedTree,
         inner_tree::InnerMap,
-        tree::{self, Leaf, Parameters, Tree},
+        path::Path,
+        tree::{self, Leaf, Parameters, Root, Tree},
         InnerDigest, LeafDigest, WithProofs,
     },
 };
@@ -288,6 +289,16 @@ where
     }
 }
 
+impl<C, F> accumulator::Types for MerkleForest<C, F>
+where
+    C: Configuration + ?Sized,
+    F: Forest<C>,
+{
+    type Item = Leaf<C>;
+    type Witness = Path<C>;
+    type Output = Root<C>;
+}
+
 impl<C, F> Accumulator for MerkleForest<C, F>
 where
     C: Configuration + ?Sized,
@@ -295,7 +306,6 @@ where
     F::Tree: WithProofs<C>,
     InnerDigest<C>: Clone + PartialEq,
 {
-    type Item = Leaf<C>;
     type Model = Parameters<C>;
 
     #[inline]
@@ -310,11 +320,6 @@ where
             .push_provable(&self.parameters, item)
     }
 
-    #[inline]
-    fn are_independent(&self, fst: &Self::Item, snd: &Self::Item) -> bool {
-        C::tree_index(fst) != C::tree_index(snd)
-    }
-
     #[inline]
     fn prove(&self, item: &Self::Item) -> Option<MembershipProof<Self::Model>> {
         let tree = self.forest.get_tree(item);
diff --git a/manta-crypto/src/merkle_tree/tree.rs b/manta-crypto/src/merkle_tree/tree.rs
index be468b41b..e8fc877ac 100644
--- a/manta-crypto/src/merkle_tree/tree.rs
+++ b/manta-crypto/src/merkle_tree/tree.rs
@@ -1046,13 +1046,22 @@ where
     }
 }
 
+impl<C, T> accumulator::Types for MerkleTree<C, T>
+where
+    C: Configuration + ?Sized,
+    T: Tree<C>,
+{
+    type Item = Leaf<C>;
+    type Witness = Path<C>;
+    type Output = Root<C>;
+}
+
 impl<C, T> Accumulator for MerkleTree<C, T>
 where
     C: Configuration + ?Sized,
     T: Tree<C> + WithProofs<C>,
     InnerDigest<C>: Clone + PartialEq,
 {
-    type Item = Leaf<C>;
     type Model = Parameters<C>;
 
     #[inline]
diff --git a/manta-crypto/src/permutation/duplex.rs b/manta-crypto/src/permutation/duplex.rs
index 68b66afd0..90844a7fb 100644
--- a/manta-crypto/src/permutation/duplex.rs
+++ b/manta-crypto/src/permutation/duplex.rs
@@ -20,6 +20,14 @@
 //       dropping it on decryption.
 
 use crate::{
+    constraint::{HasInput, Input},
+    eclair::{
+        self,
+        alloc::{mode::Public, Allocate, Allocator, Constant, Variable},
+        bool::{Assert, AssertEq, Bool},
+        ops::BitAnd,
+        Has,
+    },
     encryption::{
         CiphertextType, Decrypt, DecryptedPlaintextType, DecryptionKeyType, Encrypt,
         EncryptionKeyType, HeaderType, PlaintextType, RandomnessType,
@@ -28,9 +36,14 @@ use crate::{
         sponge::{Read, Sponge, Write},
         PseudorandomPermutation,
     },
+    rand::{Rand, RngCore, Sample},
 };
 use alloc::vec::Vec;
 use core::marker::PhantomData;
+use manta_util::{
+    codec::{self, Encode},
+    iter::{BorrowIterator, Iterable},
+};
 
 #[cfg(feature = "serde")]
 use manta_util::serde::{Deserialize, Serialize};
@@ -58,9 +71,15 @@ where
     /// Plaintext Block Type
     type PlaintextBlock: Write<P, COM, Output = Self::CiphertextBlock>;
 
+    /// Plaintext Type
+    type Plaintext: FromIterator<Self::PlaintextBlock> + BorrowIterator<Self::PlaintextBlock>;
+
     /// Ciphertext Block Type
     type CiphertextBlock: Write<P, COM, Output = Self::PlaintextBlock>;
 
+    /// Ciphertext Type
+    type Ciphertext: FromIterator<Self::CiphertextBlock> + BorrowIterator<Self::CiphertextBlock>;
+
     /// Authentication Tag Type
     type Tag: Read<P, COM>;
 }
@@ -116,6 +135,83 @@ pub struct Ciphertext<T, C> {
     pub message: C,
 }
 
+impl<T, C> Ciphertext<T, C> {
+    /// Builds a new [`Ciphertext`] from `tag` and `message`.
+    #[inline]
+    pub fn new(tag: T, message: C) -> Self {
+        Self { tag, message }
+    }
+}
+
+impl<T, C, COM> eclair::cmp::PartialEq<Self, COM> for Ciphertext<T, C>
+where
+    COM: Has<bool>,
+    Bool<COM>: BitAnd<Bool<COM>, COM, Output = Bool<COM>>,
+    T: eclair::cmp::PartialEq<T, COM>,
+    C: eclair::cmp::PartialEq<C, COM>,
+{
+    #[inline]
+    fn eq(&self, rhs: &Self, compiler: &mut COM) -> Bool<COM> {
+        self.tag
+            .eq(&rhs.tag, compiler)
+            .bitand(self.message.eq(&rhs.message, compiler), compiler)
+    }
+
+    #[inline]
+    fn assert_equal(&self, rhs: &Self, compiler: &mut COM)
+    where
+        COM: Assert,
+    {
+        compiler.assert_eq(&self.tag, &rhs.tag);
+        compiler.assert_eq(&self.message, &rhs.message);
+    }
+}
+
+impl<T, C, COM> Variable<Public, COM> for Ciphertext<T, C>
+where
+    T: Variable<Public, COM>,
+    C: Variable<Public, COM>,
+{
+    type Type = Ciphertext<T::Type, C::Type>;
+
+    #[inline]
+    fn new_unknown(compiler: &mut COM) -> Self {
+        Self::new(compiler.allocate_unknown(), compiler.allocate_unknown())
+    }
+
+    #[inline]
+    fn new_known(this: &Self::Type, compiler: &mut COM) -> Self {
+        Self::new(this.tag.as_known(compiler), this.message.as_known(compiler))
+    }
+}
+
+impl<T, C> Encode for Ciphertext<T, C>
+where
+    T: Encode,
+    C: Encode,
+{
+    #[inline]
+    fn encode<W>(&self, mut writer: W) -> Result<(), W::Error>
+    where
+        W: codec::Write,
+    {
+        self.tag.encode(&mut writer)?;
+        self.message.encode(&mut writer)?;
+        Ok(())
+    }
+}
+
+impl<T, C, P> Input<P> for Ciphertext<T, C>
+where
+    P: HasInput<T> + HasInput<C> + ?Sized,
+{
+    #[inline]
+    fn extend(&self, input: &mut P::Input) {
+        P::extend(input, &self.tag);
+        P::extend(input, &self.message);
+    }
+}
+
 /// Duplex Sponge Authenticated Encryption Scheme
 #[cfg_attr(
     feature = "serde",
@@ -174,14 +270,15 @@ where
         &self,
         key: &C::Key,
         header: &C::Header,
-        plaintext: &[C::PlaintextBlock],
+        plaintext: &C::Plaintext,
         compiler: &mut COM,
-    ) -> (C::Tag, Vec<C::CiphertextBlock>)
+    ) -> (C::Tag, C::Ciphertext)
     where
         C: Setup<P, COM>,
     {
         let mut state = self.setup(key, header, compiler);
-        let ciphertext = Sponge::new(&self.permutation, &mut state).absorb_all(plaintext, compiler);
+        let ciphertext =
+            Sponge::new(&self.permutation, &mut state).absorb_all(plaintext.iter(), compiler);
         (C::Tag::read(&state, compiler), ciphertext)
     }
 
@@ -192,18 +289,51 @@ where
         &self,
         key: &C::Key,
         header: &C::Header,
-        ciphertext: &[C::CiphertextBlock],
+        ciphertext: &C::Ciphertext,
         compiler: &mut COM,
-    ) -> (C::Tag, Vec<C::PlaintextBlock>)
+    ) -> (C::Tag, C::Plaintext)
     where
         C: Setup<P, COM>,
     {
         let mut state = self.setup(key, header, compiler);
-        let plaintext = Sponge::new(&self.permutation, &mut state).absorb_all(ciphertext, compiler);
+        let plaintext =
+            Sponge::new(&self.permutation, &mut state).absorb_all(ciphertext.iter(), compiler);
         (C::Tag::read(&state, compiler), plaintext)
     }
 }
 
+impl<P, C, COM> Constant<COM> for Duplexer<P, C, COM>
+where
+    P: PseudorandomPermutation<COM> + Constant<COM>,
+    C: Types<P, COM> + Constant<COM>,
+    P::Type: PseudorandomPermutation,
+    C::Type: Types<P::Type>,
+{
+    type Type = Duplexer<P::Type, C::Type>;
+
+    #[inline]
+    fn new_constant(this: &Self::Type, compiler: &mut COM) -> Self {
+        Self::new(
+            this.permutation.as_constant(compiler),
+            this.configuration.as_constant(compiler),
+        )
+    }
+}
+
+impl<P, C, DP, DC> Sample<(DP, DC)> for Duplexer<P, C>
+where
+    P: PseudorandomPermutation + Sample<DP>,
+    C: Sample<DC> + Types<P>,
+{
+    #[inline]
+    fn sample<R>(distribution: (DP, DC), rng: &mut R) -> Self
+    where
+        R: RngCore + ?Sized,
+    {
+        Self::new(rng.sample(distribution.0), rng.sample(distribution.1))
+    }
+}
+
 impl<P, C, COM> HeaderType for Duplexer<P, C, COM>
 where
     P: PseudorandomPermutation<COM>,
@@ -217,7 +347,7 @@ where
     P: PseudorandomPermutation<COM>,
     C: Types<P, COM>,
 {
-    type Ciphertext = Ciphertext<C::Tag, Vec<C::CiphertextBlock>>;
+    type Ciphertext = Ciphertext<C::Tag, C::Ciphertext>;
 }
 
 impl<P, C, COM> EncryptionKeyType for Duplexer<P, C, COM>
@@ -241,7 +371,7 @@ where
     P: PseudorandomPermutation<COM>,
     C: Types<P, COM>,
 {
-    type Plaintext = Vec<C::PlaintextBlock>;
+    type Plaintext = C::Plaintext;
 }
 
 impl<P, C, COM> RandomnessType for Duplexer<P, C, COM>
@@ -261,7 +391,7 @@ where
     P: PseudorandomPermutation<COM>,
     C: Verify<P, COM>,
 {
-    type DecryptedPlaintext = (C::Verification, Vec<C::PlaintextBlock>);
+    type DecryptedPlaintext = (C::Verification, C::Plaintext);
 }
 
 impl<P, C, COM> Encrypt<COM> for Duplexer<P, C, COM>
diff --git a/manta-crypto/src/rand.rs b/manta-crypto/src/rand.rs
index a2931c690..cd0a6899c 100644
--- a/manta-crypto/src/rand.rs
+++ b/manta-crypto/src/rand.rs
@@ -223,6 +223,27 @@ pub trait Sample<D = ()>: Sized {
     }
 }
 
+impl<T, D> Sample<D> for PhantomData<T> {
+    #[inline]
+    fn sample<R>(distribution: D, rng: &mut R) -> Self
+    where
+        R: RngCore + ?Sized,
+    {
+        let _ = (distribution, rng);
+        Self
+    }
+}
+
+impl<D> Sample<D> for () {
+    #[inline]
+    fn sample<R>(distribution: D, rng: &mut R) -> Self
+    where
+        R: RngCore + ?Sized,
+    {
+        let _ = (distribution, rng);
+    }
+}
+
 impl Sample for bool {
     #[inline]
     fn sample<R>(_: (), rng: &mut R) -> Self
diff --git a/manta-crypto/src/signature/convert.rs b/manta-crypto/src/signature/convert.rs
new file mode 100644
index 000000000..96f9b3595
--- /dev/null
+++ b/manta-crypto/src/signature/convert.rs
@@ -0,0 +1,232 @@
+// Copyright 2019-2022 Manta Network.
+// This file is part of manta-rs.
+//
+// manta-rs is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// manta-rs is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with manta-rs.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Signature Scheme Message Conversion Primitives and Adapters
+
+use crate::{
+    eclair::alloc::Constant,
+    rand::{Rand, RngCore, Sample},
+    signature::{
+        Derive, MessageType, RandomnessType, Sign, SignatureType, SigningKeyType, Verify,
+        VerifyingKeyType,
+    },
+};
+use core::marker::PhantomData;
+use manta_util::codec::{Decode, DecodeError, Encode, Read, Write};
+
+#[cfg(feature = "serde")]
+use manta_util::serde::{Deserialize, Serialize};
+
+/// Forward Conversion
+///
+/// When signing a message over [`TargetMessage`] we can apply the [`as_target`] conversion function
+/// to objects of type [`Message`] to make them compatible with signing.
+///
+/// [`TargetMessage`]: Self::TargetMessage
+/// [`as_target`]: Self::as_target
+/// [`Message`]: MessageType::Message
+pub trait Forward<COM = ()>: MessageType {
+    /// Target Message Type
+    type TargetMessage;
+
+    /// Converts `source` into the [`TargetMessage`](Self::TargetMessage) type.
+    fn as_target(source: &Self::Message, compiler: &mut COM) -> Self::TargetMessage;
+}
+
+/// Message-Converting Signature Scheme Adapter
+///
+/// In many applications we may have some structured message data that feeds into a generic
+/// signature scheme over some unstructured type (like signing a bit-string message). This converter
+/// can be used to convert between the message types for conversion before signing. This `struct`
+/// utilizes the [`Forward`] `trait` to give the definition of the conversion. The `C` type on this
+/// `struct` is the converter that implements [`Forward`].
+#[cfg_attr(
+    feature = "serde",
+    derive(Deserialize, Serialize),
+    serde(crate = "manta_util::serde", deny_unknown_fields)
+)]
+#[derive(derivative::Derivative)]
+#[derivative(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct Converter<S, C> {
+    /// Base Signature Scheme
+    pub base: S,
+
+    /// Type Parameter Marker
+    __: PhantomData<C>,
+}
+
+impl<S, C> Converter<S, C> {
+    /// Builds a new [`Converter`] over `base`.
+    #[inline]
+    pub fn new(base: S) -> Self {
+        Self {
+            base,
+            __: PhantomData,
+        }
+    }
+
+    /// Returns the inner signature scheme from `self`.
+    #[inline]
+    pub fn into_inner(self) -> S {
+        self.base
+    }
+}
+
+impl<S, C> SigningKeyType for Converter<S, C>
+where
+    S: SigningKeyType,
+{
+    type SigningKey = S::SigningKey;
+}
+
+impl<S, C> VerifyingKeyType for Converter<S, C>
+where
+    S: VerifyingKeyType,
+{
+    type VerifyingKey = S::VerifyingKey;
+}
+
+impl<S, C> MessageType for Converter<S, C>
+where
+    C: MessageType,
+{
+    type Message = C::Message;
+}
+
+impl<S, C> SignatureType for Converter<S, C>
+where
+    S: SignatureType,
+{
+    type Signature = S::Signature;
+}
+
+impl<S, C> RandomnessType for Converter<S, C>
+where
+    S: RandomnessType,
+{
+    type Randomness = S::Randomness;
+}
+
+impl<S, C, COM> Derive<COM> for Converter<S, C>
+where
+    S: Derive<COM>,
+{
+    #[inline]
+    fn derive(&self, signing_key: &Self::SigningKey, compiler: &mut COM) -> Self::VerifyingKey {
+        self.base.derive(signing_key, compiler)
+    }
+}
+
+impl<S, C, COM> Sign<COM> for Converter<S, C>
+where
+    S: Sign<COM, Message = C::TargetMessage>,
+    C: Forward<COM>,
+{
+    #[inline]
+    fn sign(
+        &self,
+        signing_key: &Self::SigningKey,
+        randomness: &Self::Randomness,
+        message: &Self::Message,
+        compiler: &mut COM,
+    ) -> Self::Signature {
+        self.base.sign(
+            signing_key,
+            randomness,
+            &C::as_target(message, compiler),
+            compiler,
+        )
+    }
+}
+
+impl<S, C, COM> Verify<COM> for Converter<S, C>
+where
+    S: Verify<COM, Message = C::TargetMessage>,
+    C: Forward<COM>,
+{
+    type Verification = S::Verification;
+
+    #[inline]
+    fn verify(
+        &self,
+        verifying_key: &Self::VerifyingKey,
+        message: &Self::Message,
+        signature: &Self::Signature,
+        compiler: &mut COM,
+    ) -> Self::Verification {
+        self.base.verify(
+            verifying_key,
+            &C::as_target(message, compiler),
+            signature,
+            compiler,
+        )
+    }
+}
+
+impl<S, C, COM> Constant<COM> for Converter<S, C>
+where
+    S: Constant<COM>,
+    C: Constant<COM>,
+{
+    type Type = Converter<S::Type, C::Type>;
+
+    #[inline]
+    fn new_constant(this: &Self::Type, compiler: &mut COM) -> Self {
+        Self::new(Constant::new_constant(&this.base, compiler))
+    }
+}
+
+impl<S, C> Decode for Converter<S, C>
+where
+    S: Decode,
+{
+    type Error = S::Error;
+
+    #[inline]
+    fn decode<R>(mut reader: R) -> Result<Self, DecodeError<R::Error, Self::Error>>
+    where
+        R: Read,
+    {
+        Ok(Self::new(Decode::decode(&mut reader)?))
+    }
+}
+
+impl<S, C> Encode for Converter<S, C>
+where
+    S: Encode,
+{
+    #[inline]
+    fn encode<W>(&self, mut writer: W) -> Result<(), W::Error>
+    where
+        W: Write,
+    {
+        self.base.encode(&mut writer)?;
+        Ok(())
+    }
+}
+
+impl<S, C, D> Sample<D> for Converter<S, C>
+where
+    S: Sample<D>,
+{
+    #[inline]
+    fn sample<R>(distribution: D, rng: &mut R) -> Self
+    where
+        R: RngCore + ?Sized,
+    {
+        Self::new(rng.sample(distribution))
+    }
+}
diff --git a/manta-crypto/src/signature.rs b/manta-crypto/src/signature/mod.rs
similarity index 63%
rename from manta-crypto/src/signature.rs
rename to manta-crypto/src/signature/mod.rs
index 07280e421..c84e31810 100644
--- a/manta-crypto/src/signature.rs
+++ b/manta-crypto/src/signature/mod.rs
@@ -34,6 +34,8 @@
 //!
 //! See the [`correctness`](test::correctness) test for more.
 
+pub mod convert;
+
 /// Signing Key
 pub trait SigningKeyType {
     /// Signing Key Type
@@ -47,6 +49,9 @@ where
     type SigningKey = T::SigningKey;
 }
 
+/// Signing Key Type
+pub type SigningKey<T> = <T as SigningKeyType>::SigningKey;
+
 /// Verifying Key
 pub trait VerifyingKeyType {
     /// Verifying Key Type
@@ -60,6 +65,9 @@ where
     type VerifyingKey = T::VerifyingKey;
 }
 
+/// Verifying Key Type
+pub type VerifyingKey<T> = <T as VerifyingKeyType>::VerifyingKey;
+
 /// Message
 pub trait MessageType {
     /// Message Type
@@ -73,6 +81,9 @@ where
     type Message = T::Message;
 }
 
+/// Message Type
+pub type Message<T> = <T as MessageType>::Message;
+
 /// Signature
 pub trait SignatureType {
     /// Signature Type
@@ -86,6 +97,9 @@ where
     type Signature = T::Signature;
 }
 
+/// Signature Type
+pub type Signature<T> = <T as SignatureType>::Signature;
+
 /// Randomness
 pub trait RandomnessType {
     /// Randomness Type
@@ -99,6 +113,9 @@ where
     type Randomness = T::Randomness;
 }
 
+/// Randomness Type
+pub type Randomness<T> = <T as RandomnessType>::Randomness;
+
 /// Signature Verifying Key Derivation Function
 pub trait Derive<COM = ()>: SigningKeyType + VerifyingKeyType {
     /// Derives the verifying key from `signing_key`.
@@ -176,6 +193,7 @@ where
 {
     type Verification = V::Verification;
 
+    #[inline]
     fn verify(
         &self,
         verifying_key: &Self::VerifyingKey,
@@ -191,50 +209,69 @@ where
 pub mod schnorr {
     use super::*;
     use crate::{
-        algebra::{security::DiscreteLogarithmHardness, Group, Scalar},
-        eclair::{bool::Bool, cmp::PartialEq, Has},
+        algebra::{
+            security::DiscreteLogarithmHardness, Group as _, HasGenerator, Ring, ScalarMul,
+            ScalarMulGroup,
+        },
+        eclair::{
+            alloc::{Const, Constant},
+            bool::Bool,
+            cmp::PartialEq,
+            Has,
+        },
         hash::security::PreimageResistance,
+        rand::{Rand, RngCore, Sample},
     };
     use core::{cmp, fmt::Debug, hash::Hash, marker::PhantomData};
 
     /// Schnorr Signature Hash Function
-    pub trait HashFunction<G, COM = ()>: PreimageResistance
-    where
-        G: DiscreteLogarithmHardness + Group<COM>,
-    {
+    pub trait HashFunction<COM = ()>: PreimageResistance {
+        /// Scalar Type
+        type Scalar: Ring<COM>;
+
+        /// Group Type
+        type Group: ScalarMulGroup<Self::Scalar, COM, Output = Self::Group>
+            + DiscreteLogarithmHardness;
+
         /// Message Type
         type Message;
 
-        /// Hashes `message` along with `verifying_key` and `nonce_point` into a
-        /// [`Scalar`](Group::Scalar).
+        /// Hashes `message` along with `verifying_key` and `nonce_point` into a scalar of type
+        /// [`Scalar`](Self::Scalar).
         fn hash(
             &self,
-            verifying_key: &G,
-            nonce_point: &G,
+            verifying_key: &Self::Group,
+            nonce_point: &Self::Group,
             message: &Self::Message,
             compiler: &mut COM,
-        ) -> G::Scalar;
+        ) -> Self::Scalar;
     }
 
+    /// Scalar Type
+    pub type Scalar<H, COM = ()> = <H as HashFunction<COM>>::Scalar;
+
+    /// Group Type
+    pub type Group<H, COM = ()> = <H as HashFunction<COM>>::Group;
+
+    /// Message Type
+    pub type Message<H, COM = ()> = <H as HashFunction<COM>>::Message;
+
     /// Schnorr Signature
     #[derive(derivative::Derivative)]
     #[derivative(
-        Clone(bound = "G::Scalar: Clone, G: Clone"),
-        Copy(bound = "G::Scalar: Copy, G: Copy"),
-        Debug(bound = "G::Scalar: Debug, G: Debug"),
-        Eq(bound = "G::Scalar: Eq, G: Eq"),
-        Hash(bound = "G::Scalar: Hash, G: Hash"),
-        PartialEq(bound = "G::Scalar: cmp::PartialEq, G: cmp::PartialEq")
+        Clone(bound = "S: Clone, G: Clone"),
+        Copy(bound = "S: Copy, G: Copy"),
+        Debug(bound = "S: Debug, G: Debug"),
+        Eq(bound = "S: Eq, G: Eq"),
+        Hash(bound = "S: Hash, G: Hash"),
+        PartialEq(bound = "S: cmp::PartialEq, G: cmp::PartialEq")
     )]
-    pub struct Signature<G, COM = ()>
-    where
-        G: DiscreteLogarithmHardness + Group<COM>,
-    {
+    pub struct Signature<S, G> {
         /// Scalar
         ///
         /// This scalar is the hash output multiplied by the secret key, blinded by the nonce
         /// factor.
-        pub scalar: G::Scalar,
+        pub scalar: S,
 
         /// Nonce Point
         ///
@@ -245,83 +282,116 @@ pub mod schnorr {
     /// Schnorr Signature Scheme
     #[derive(derivative::Derivative)]
     #[derivative(
-        Clone(bound = "G: Clone, H: Clone"),
-        Copy(bound = "G: Copy, H: Copy"),
-        Debug(bound = "G: Debug, H: Debug"),
-        Eq(bound = "G: Eq, H: Eq"),
-        Hash(bound = "G: Hash, H: Hash"),
-        PartialEq(bound = "G: cmp::PartialEq, H: cmp::PartialEq")
+        Clone(bound = "H:Clone, H::Group: Clone"),
+        Copy(bound = "H: Copy, H::Group: Copy"),
+        Debug(bound = "H: Debug, H::Group: Debug"),
+        Eq(bound = "H: Eq, H::Group: Eq"),
+        Hash(bound = "H: Hash, H::Group: Hash"),
+        PartialEq(bound = "H: cmp::PartialEq, H::Group: cmp::PartialEq")
     )]
-    pub struct Schnorr<G, H, COM = ()>
+    pub struct Schnorr<H, COM = ()>
     where
-        G: DiscreteLogarithmHardness + Group<COM>,
-        H: HashFunction<G, COM>,
+        H: HashFunction<COM>,
     {
-        /// Schnorr Group Generator
-        pub generator: G,
-
         /// Schnorr Hash Function
         pub hash_function: H,
 
+        /// Schnorr Group Generator
+        pub generator: H::Group,
+
         /// Type Parameter Marker
         __: PhantomData<COM>,
     }
 
-    impl<G, H, COM> SigningKeyType for Schnorr<G, H, COM>
+    impl<H, COM> Schnorr<H, COM>
     where
-        G: DiscreteLogarithmHardness + Group<COM>,
-        H: HashFunction<G, COM>,
+        H: HashFunction<COM>,
     {
-        type SigningKey = G::Scalar;
+        /// Builds a new [`Schnorr`] signature scheme over `hash_function` and `generator`.
+        #[inline]
+        pub fn new(hash_function: H, generator: H::Group) -> Self {
+            Self {
+                hash_function,
+                generator,
+                __: PhantomData,
+            }
+        }
     }
 
-    impl<G, H, COM> VerifyingKeyType for Schnorr<G, H, COM>
+    impl<H, COM> HasGenerator<H::Group, COM> for Schnorr<H, COM>
     where
-        G: DiscreteLogarithmHardness + Group<COM>,
-        H: HashFunction<G, COM>,
+        H: HashFunction<COM>,
     {
-        type VerifyingKey = G;
+        type Generator = H::Group;
+
+        #[inline]
+        fn generator(&self) -> &Self::Generator {
+            &self.generator
+        }
+    }
+
+    impl<H, DG, DH> Sample<(DH, DG)> for Schnorr<H>
+    where
+        H: HashFunction + Sample<DH>,
+        H::Group: Sample<DG>,
+    {
+        #[inline]
+        fn sample<R>(distribution: (DH, DG), rng: &mut R) -> Self
+        where
+            R: RngCore + ?Sized,
+        {
+            Self::new(rng.sample(distribution.0), rng.sample(distribution.1))
+        }
+    }
+
+    impl<H, COM> SigningKeyType for Schnorr<H, COM>
+    where
+        H: HashFunction<COM>,
+    {
+        type SigningKey = H::Scalar;
     }
 
-    impl<G, H, COM> MessageType for Schnorr<G, H, COM>
+    impl<H, COM> VerifyingKeyType for Schnorr<H, COM>
     where
-        G: DiscreteLogarithmHardness + Group<COM>,
-        H: HashFunction<G, COM>,
+        H: HashFunction<COM>,
+    {
+        type VerifyingKey = H::Group;
+    }
+
+    impl<H, COM> MessageType for Schnorr<H, COM>
+    where
+        H: HashFunction<COM>,
     {
         type Message = H::Message;
     }
 
-    impl<G, H, COM> SignatureType for Schnorr<G, H, COM>
+    impl<H, COM> SignatureType for Schnorr<H, COM>
     where
-        G: DiscreteLogarithmHardness + Group<COM>,
-        H: HashFunction<G, COM>,
+        H: HashFunction<COM>,
     {
-        type Signature = Signature<G, COM>;
+        type Signature = Signature<H::Scalar, H::Group>;
     }
 
-    impl<G, H, COM> RandomnessType for Schnorr<G, H, COM>
+    impl<H, COM> RandomnessType for Schnorr<H, COM>
     where
-        G: DiscreteLogarithmHardness + Group<COM>,
-        H: HashFunction<G, COM>,
+        H: HashFunction<COM>,
     {
-        type Randomness = G::Scalar;
+        type Randomness = H::Scalar;
     }
 
-    impl<G, H, COM> Derive<COM> for Schnorr<G, H, COM>
+    impl<H, COM> Derive<COM> for Schnorr<H, COM>
     where
-        G: DiscreteLogarithmHardness + Group<COM>,
-        H: HashFunction<G, COM>,
+        H: HashFunction<COM>,
     {
         #[inline]
         fn derive(&self, signing_key: &Self::SigningKey, compiler: &mut COM) -> Self::VerifyingKey {
-            self.generator.mul(signing_key, compiler)
+            self.generator.scalar_mul(signing_key, compiler)
         }
     }
 
-    impl<G, H, COM> Sign<COM> for Schnorr<G, H, COM>
+    impl<H, COM> Sign<COM> for Schnorr<H, COM>
     where
-        G: DiscreteLogarithmHardness + Group<COM>,
-        H: HashFunction<G, COM>,
+        H: HashFunction<COM>,
     {
         #[inline]
         fn sign(
@@ -331,12 +401,12 @@ pub mod schnorr {
             message: &Self::Message,
             compiler: &mut COM,
         ) -> Self::Signature {
-            let nonce_point = self.generator.mul(randomness, compiler);
+            let nonce_point = self.generator.scalar_mul(randomness, compiler);
             Signature {
                 scalar: randomness.add(
                     &signing_key.mul(
                         &self.hash_function.hash(
-                            &self.generator.mul(signing_key, compiler),
+                            &self.generator.scalar_mul(signing_key, compiler),
                             &nonce_point,
                             message,
                             compiler,
@@ -350,11 +420,11 @@ pub mod schnorr {
         }
     }
 
-    impl<G, H, COM> Verify<COM> for Schnorr<G, H, COM>
+    impl<H, COM> Verify<COM> for Schnorr<H, COM>
     where
-        G: DiscreteLogarithmHardness + Group<COM> + PartialEq<G, COM>,
-        H: HashFunction<G, COM>,
         COM: Has<bool>,
+        H: HashFunction<COM>,
+        H::Group: PartialEq<H::Group, COM>,
     {
         type Verification = Bool<COM>;
 
@@ -370,9 +440,9 @@ pub mod schnorr {
                 scalar,
                 nonce_point,
             } = signature;
-            self.generator.mul(scalar, compiler).eq(
+            self.generator.scalar_mul(scalar, compiler).eq(
                 &nonce_point.add(
-                    &verifying_key.mul(
+                    &verifying_key.scalar_mul(
                         &self
                             .hash_function
                             .hash(verifying_key, nonce_point, message, compiler),
@@ -384,6 +454,24 @@ pub mod schnorr {
             )
         }
     }
+
+    impl<H, COM> Constant<COM> for Schnorr<H, COM>
+    where
+        H: Constant<COM> + HashFunction<COM>,
+        H::Type: HashFunction<Group = Const<H::Group, COM>>,
+        H::Group: Constant<COM>,
+        Const<H::Group, COM>: ScalarMulGroup<H::Scalar> + DiscreteLogarithmHardness,
+    {
+        type Type = Schnorr<H::Type>;
+
+        #[inline]
+        fn new_constant(this: &Self::Type, compiler: &mut COM) -> Self {
+            Self::new(
+                H::new_constant(&this.hash_function, compiler),
+                H::Group::new_constant(&this.generator, compiler),
+            )
+        }
+    }
 }
 
 /// Testing Framework
diff --git a/manta-parameters/Cargo.toml b/manta-parameters/Cargo.toml
index 7d4ff6290..41481faea 100644
--- a/manta-parameters/Cargo.toml
+++ b/manta-parameters/Cargo.toml
@@ -32,7 +32,7 @@ download = ["anyhow", "attohttpc", "std"]
 std = ["anyhow?/std"]
 
 [dependencies]
-anyhow = { version = "1.0.57", optional = true, default-features = false }
+anyhow = { version = "1.0.62", optional = true, default-features = false }
 attohttpc = { version = "0.19.1", optional = true }
 blake3 = { version = "1.3.1", default-features = false }
 workspace-hack = { version = "0.1.0", path = "../workspace-hack" }
@@ -45,7 +45,7 @@ tempfile = { version = "3.3.0", default-features = false }
 walkdir = { version = "2.3.2", default-features = false }
 
 [build-dependencies]
-anyhow = { version = "1.0.57", default-features = false, features = ["std"] }
+anyhow = { version = "1.0.62", default-features = false, features = ["std"] }
 blake3 = { version = "1.3.1", default-features = false, features = ["std"] }
 hex = { version = "0.4.3", default-features = false, features = ["std"] }
 walkdir = { version = "2.3.2", default-features = false }
diff --git a/manta-pay/Cargo.toml b/manta-pay/Cargo.toml
index a2f69e358..d927f5b0e 100644
--- a/manta-pay/Cargo.toml
+++ b/manta-pay/Cargo.toml
@@ -105,10 +105,10 @@ ark-ed-on-bls12-381 = { version = "0.3.0", optional = true, default-features = f
 ark-groth16 = { version = "0.3.0", optional = true, default-features = false }
 ark-snark = { version = "0.3.0", optional = true, default-features = false }
 ark-std = { version = "0.3.0", optional = true, default-features = false }
-bip32 = { version = "0.4.0", optional = true, default-features = false, features = ["bip39", "secp256k1"] }
+bip32 = { version = "0.3.0", optional = true, default-features = false, features = ["bip39", "secp256k1"] }
 blake2 = { version = "0.10.4", default-features = false }
 bs58 = { version = "0.4.0", optional = true, default-features = false, features = ["alloc"] }
-clap = { version = "3.2.15", optional = true, default-features = false, features = ["color", "derive", "std", "suggestions", "unicode", "wrap_help"] }
+clap = { version = "3.2.17", optional = true, default-features = false, features = ["color", "derive", "std", "suggestions", "unicode", "wrap_help"] }
 derivative = { version = "2.2.0", default-features = false, features = ["use_core"] }
 futures = { version = "0.3.21", optional = true, default-features = false }
 indexmap = { version = "1.8.2", optional = true, default-features = false }
@@ -121,7 +121,7 @@ rand_chacha = { version = "0.3.1", default-features = false }
 rayon = { version = "1.5.1", optional = true, default-features = false }
 scale-codec = { package = "parity-scale-codec", version = "3.1.2", optional = true, default-features = false, features = ["derive", "max-encoded-len"] }
 scale-info = { version = "2.1.2", optional = true, default-features = false, features = ["derive"] }
-serde_json = { version = "1.0.82", optional = true, default-features = false, features = ["alloc"] }
+serde_json = { version = "1.0.85", optional = true, default-features = false, features = ["alloc"] }
 tempfile = { version = "3.3.0", optional = true, default-features = false }
 tide = { version = "0.16.0", optional = true, default-features = false, features = ["h1-server"] }
 tokio = { version = "1.20.1", optional = true, default-features = false }
diff --git a/manta-pay/src/config.rs b/manta-pay/src/config.rs
index fb9b9ab94..633314283 100644
--- a/manta-pay/src/config.rs
+++ b/manta-pay/src/config.rs
@@ -41,7 +41,7 @@ use manta_crypto::{
         ff::ToConstraintField,
         serialize::{CanonicalDeserialize, CanonicalSerialize, SerializationError},
     },
-    constraint::ProofSystemInput,
+    constraint::Input,
     eclair::{
         self,
         alloc::{
@@ -52,15 +52,12 @@ use manta_crypto::{
     },
     encryption,
     hash::ArrayHashFunction,
-    key::{
-        self,
-        kdf::{AsBytes, KeyDerivationFunction},
-    },
+    key::{self, kdf::KeyDerivationFunction},
     merkle_tree,
 };
 use manta_util::{
     codec::{Decode, DecodeError, Encode, Read, Write},
-    into_array_unchecked, Array, SizeLimit,
+    into_array_unchecked, Array, AsBytes, SizeLimit,
 };
 
 #[cfg(feature = "bs58")]
@@ -153,7 +150,7 @@ impl poseidon::arkworks::Specification for PoseidonSpec<4> {
 }
 
 /// Key Agreement Scheme Type
-pub type KeyAgreementScheme = DiffieHellman<Group>;
+pub type KeyAgreementScheme = DiffieHellman<EmbeddedScalar, Group>;
 
 /// Secret Key Type
 pub type SecretKey = <KeyAgreementScheme as key::agreement::Types>::SecretKey;
@@ -165,7 +162,7 @@ pub type PublicKey = <KeyAgreementScheme as key::agreement::Types>::PublicKey;
 pub type SharedSecret = <KeyAgreementScheme as key::agreement::Types>::SharedSecret;
 
 /// Key Agreement Scheme Variable Type
-pub type KeyAgreementSchemeVar = DiffieHellman<GroupVar, Compiler>;
+pub type KeyAgreementSchemeVar = DiffieHellman<EmbeddedScalarVar, GroupVar>;
 
 /// Secret Key Variable Type
 pub type SecretKeyVar = <KeyAgreementSchemeVar as key::agreement::Types>::SecretKey;
@@ -633,31 +630,24 @@ impl Constant<Compiler> for MerkleTreeConfigurationVar {
     }
 }
 
-impl ProofSystemInput<AssetId> for ProofSystem {
-    #[inline]
-    fn extend(input: &mut Self::Input, next: &AssetId) {
-        input.push(next.0.into());
-    }
-}
-
-impl ProofSystemInput<AssetValue> for ProofSystem {
+impl Input<ProofSystem> for AssetId {
     #[inline]
-    fn extend(input: &mut Self::Input, next: &AssetValue) {
-        input.push(next.0.into());
+    fn extend(&self, input: &mut Vec<ConstraintField>) {
+        input.push(self.0.into());
     }
 }
 
-impl ProofSystemInput<Fp<ConstraintField>> for ProofSystem {
+impl Input<ProofSystem> for AssetValue {
     #[inline]
-    fn extend(input: &mut Self::Input, next: &Fp<ConstraintField>) {
-        input.push(next.0);
+    fn extend(&self, input: &mut Vec<ConstraintField>) {
+        input.push(self.0.into());
     }
 }
 
-impl ProofSystemInput<Group> for ProofSystem {
+impl Input<ProofSystem> for Group {
     #[inline]
-    fn extend(input: &mut Self::Input, next: &Group) {
-        input.append(&mut next.0.to_field_elements().unwrap());
+    fn extend(&self, input: &mut Vec<ConstraintField>) {
+        input.append(&mut self.0.to_field_elements().unwrap());
     }
 }
 
diff --git a/manta-pay/src/crypto/constraint/arkworks/groth16.rs b/manta-pay/src/crypto/constraint/arkworks/groth16.rs
index ce15573df..ae6473911 100644
--- a/manta-pay/src/crypto/constraint/arkworks/groth16.rs
+++ b/manta-pay/src/crypto/constraint/arkworks/groth16.rs
@@ -30,7 +30,7 @@ use manta_crypto::{
         ec::PairingEngine,
         serialize::{CanonicalDeserialize, CanonicalSerialize, Read, Write},
     },
-    constraint::ProofSystem,
+    constraint::{Input, ProofSystem},
     rand::{CryptoRng, RngCore, SizedRng},
 };
 use manta_util::codec::{self, DecodeError};
@@ -138,6 +138,19 @@ where
     }
 }
 
+impl<E> codec::Encode for Proof<E>
+where
+    E: PairingEngine,
+{
+    #[inline]
+    fn encode<W>(&self, writer: W) -> Result<(), W::Error>
+    where
+        W: codec::Write,
+    {
+        proof_as_bytes(&self.0).encode(writer)
+    }
+}
+
 impl<E> TryFrom<Vec<u8>> for Proof<E>
 where
     E: PairingEngine,
@@ -510,3 +523,23 @@ where
         ArkGroth16::verify_with_processed_vk(&context.0, input, &proof.0).map_err(|_| Error)
     }
 }
+
+impl<E> Input<Groth16<E>> for bool
+where
+    E: PairingEngine,
+{
+    #[inline]
+    fn extend(&self, input: &mut Vec<E::Fr>) {
+        input.push((*self).into());
+    }
+}
+
+impl<E> Input<Groth16<E>> for u128
+where
+    E: PairingEngine,
+{
+    #[inline]
+    fn extend(&self, input: &mut Vec<E::Fr>) {
+        input.push((*self).into());
+    }
+}
diff --git a/manta-pay/src/crypto/constraint/arkworks/mod.rs b/manta-pay/src/crypto/constraint/arkworks/mod.rs
index 610bf29d0..1be20c847 100644
--- a/manta-pay/src/crypto/constraint/arkworks/mod.rs
+++ b/manta-pay/src/crypto/constraint/arkworks/mod.rs
@@ -17,10 +17,11 @@
 //! Arkworks Constraint System and Proof System Implementations
 
 use alloc::vec::Vec;
+use core::iter::{self, Extend};
 use manta_crypto::{
     algebra,
     arkworks::{
-        ff::{Field, FpParameters, PrimeField},
+        ff::{Field, FpParameters, PrimeField, ToConstraintField},
         r1cs_std::{alloc::AllocVar, eq::EqGadget, select::CondSelectGadget, ToBitsGadget},
         relations::{
             ns,
@@ -30,17 +31,19 @@ use manta_crypto::{
             },
         },
     },
-    constraint::measure::{Count, Measure},
+    constraint::{
+        measure::{Count, Measure},
+        Input, ProofSystem,
+    },
     eclair::{
         self,
         alloc::{
-            mode,
-            mode::{Public, Secret},
+            mode::{self, Public, Secret},
             Constant, Variable,
         },
-        bool::{Assert, ConditionalSwap},
-        num::AssertWithinBitRange,
-        ops::{Add, BitAnd},
+        bool::{Assert, Bool, ConditionalSelect, ConditionalSwap},
+        num::{AssertWithinBitRange, Zero},
+        ops::{Add, BitAnd, BitOr},
         Has, NonNative,
     },
     rand::{RngCore, Sample},
@@ -89,6 +92,38 @@ pub struct Fp<F>(
 where
     F: Field;
 
+impl<F> From<u128> for Fp<F>
+where
+    F: Field,
+{
+    #[inline]
+    fn from(value: u128) -> Self {
+        Self(value.into())
+    }
+}
+
+impl<F> ToConstraintField<F> for Fp<F>
+where
+    F: PrimeField,
+{
+    #[inline]
+    fn to_field_elements(&self) -> Option<Vec<F>> {
+        self.0.to_field_elements()
+    }
+}
+
+impl<F, P> Input<P> for Fp<F>
+where
+    F: Field,
+    P: ProofSystem + ?Sized,
+    P::Input: Extend<F>,
+{
+    #[inline]
+    fn extend(&self, input: &mut P::Input) {
+        input.extend(iter::once(self.0))
+    }
+}
+
 impl<F> Decode for Fp<F>
 where
     F: Field,
@@ -191,6 +226,64 @@ where
     }
 }
 
+impl<F> eclair::cmp::PartialEq<Self> for Fp<F>
+where
+    F: Field,
+{
+    #[inline]
+    fn eq(&self, rhs: &Self, _: &mut ()) -> bool {
+        PartialEq::eq(self, rhs)
+    }
+}
+
+impl<F> eclair::num::Zero for Fp<F>
+where
+    F: Field,
+{
+    type Verification = bool;
+
+    #[inline]
+    fn zero(_: &mut ()) -> Self {
+        Self(F::zero())
+    }
+
+    #[inline]
+    fn is_zero(&self, _: &mut ()) -> Self::Verification {
+        self.0.is_zero()
+    }
+}
+
+impl<F> eclair::num::One for Fp<F>
+where
+    F: Field,
+{
+    type Verification = bool;
+
+    #[inline]
+    fn one(_: &mut ()) -> Self {
+        Self(F::one())
+    }
+
+    #[inline]
+    fn is_one(&self, _: &mut ()) -> Self::Verification {
+        self.0.is_one()
+    }
+}
+
+impl<F> ConditionalSelect for Fp<F>
+where
+    F: Field,
+{
+    #[inline]
+    fn select(bit: &Bool, true_value: &Self, false_value: &Self, _: &mut ()) -> Self {
+        if *bit {
+            *true_value
+        } else {
+            *false_value
+        }
+    }
+}
+
 impl<F> Sample for Fp<F>
 where
     F: Field,
@@ -204,7 +297,7 @@ where
     }
 }
 
-impl<F> algebra::Scalar for Fp<F>
+impl<F> algebra::Group for Fp<F>
 where
     F: Field,
 {
@@ -212,7 +305,12 @@ where
     fn add(&self, rhs: &Self, _: &mut ()) -> Self {
         Self(self.0 + rhs.0)
     }
+}
 
+impl<F> algebra::Ring for Fp<F>
+where
+    F: Field,
+{
     #[inline]
     fn mul(&self, rhs: &Self, _: &mut ()) -> Self {
         Self(self.0 * rhs.0)
@@ -492,6 +590,19 @@ where
     }
 }
 
+impl<F> BitOr<Self, R1CS<F>> for Boolean<F>
+where
+    F: PrimeField,
+{
+    type Output = Self;
+
+    #[inline]
+    fn bitor(self, rhs: Self, compiler: &mut R1CS<F>) -> Self::Output {
+        let _ = compiler;
+        self.or(&rhs).expect("Bitwise OR is not allowed to fail.")
+    }
+}
+
 impl<F> Constant<R1CS<F>> for FpVar<F>
 where
     F: PrimeField,
@@ -578,6 +689,22 @@ where
         .expect("Conditionally selecting from two values is not allowed to fail.")
 }
 
+impl<F> ConditionalSelect<R1CS<F>> for FpVar<F>
+where
+    F: PrimeField,
+{
+    #[inline]
+    fn select(
+        bit: &Boolean<F>,
+        true_value: &Self,
+        false_value: &Self,
+        compiler: &mut R1CS<F>,
+    ) -> Self {
+        let _ = compiler;
+        conditionally_select(bit, true_value, false_value)
+    }
+}
+
 impl<F> ConditionalSwap<R1CS<F>> for FpVar<F>
 where
     F: PrimeField,
@@ -605,6 +732,26 @@ where
     }
 }
 
+impl<F> Zero<R1CS<F>> for FpVar<F>
+where
+    F: PrimeField,
+{
+    type Verification = Boolean<F>;
+
+    #[inline]
+    fn zero(compiler: &mut R1CS<F>) -> Self {
+        let _ = compiler;
+        FpVar::Constant(F::zero())
+    }
+
+    #[inline]
+    fn is_zero(&self, compiler: &mut R1CS<F>) -> Self::Verification {
+        let _ = compiler;
+        self.is_eq(&FpVar::Constant(F::zero()))
+            .expect("Comparison with zero is not allowed to fail.")
+    }
+}
+
 /// Testing Suite
 #[cfg(test)]
 mod tests {
diff --git a/manta-pay/src/crypto/ecc/arkworks.rs b/manta-pay/src/crypto/ecc/arkworks.rs
index 835d38e1f..d2c967127 100644
--- a/manta-pay/src/crypto/ecc/arkworks.rs
+++ b/manta-pay/src/crypto/ecc/arkworks.rs
@@ -36,10 +36,9 @@ use manta_crypto::{
             Allocate, Allocator, Constant, Variable,
         },
     },
-    key::kdf,
     rand::{RngCore, Sample},
 };
-use manta_util::codec;
+use manta_util::{codec, AsBytes};
 
 #[cfg(feature = "serde")]
 use {
@@ -203,7 +202,7 @@ where
     }
 }
 
-impl<C> kdf::AsBytes for Group<C>
+impl<C> AsBytes for Group<C>
 where
     C: ProjectiveCurve,
 {
@@ -217,15 +216,20 @@ impl<C> algebra::Group for Group<C>
 where
     C: ProjectiveCurve,
 {
-    type Scalar = Scalar<C>;
-
     #[inline]
     fn add(&self, rhs: &Self, _: &mut ()) -> Self {
         Self(self.0 + rhs.0)
     }
+}
+
+impl<C> algebra::ScalarMul<Scalar<C>> for Group<C>
+where
+    C: ProjectiveCurve,
+{
+    type Output = Self;
 
     #[inline]
-    fn mul(&self, scalar: &Self::Scalar, _: &mut ()) -> Self {
+    fn scalar_mul(&self, scalar: &Scalar<C>, _: &mut ()) -> Self::Output {
         Self(self.0.mul(scalar.0.into_repr()).into())
     }
 }
@@ -288,7 +292,7 @@ where
     }
 }
 
-impl<C, CV> algebra::Scalar<Compiler<C>> for ScalarVar<C, CV>
+impl<C, CV> algebra::Group<Compiler<C>> for ScalarVar<C, CV>
 where
     C: ProjectiveCurve,
     CV: CurveVar<C, ConstraintField<C>>,
@@ -298,7 +302,13 @@ where
         let _ = compiler;
         Self::new(&self.0 + &rhs.0)
     }
+}
 
+impl<C, CV> algebra::Ring<Compiler<C>> for ScalarVar<C, CV>
+where
+    C: ProjectiveCurve,
+    CV: CurveVar<C, ConstraintField<C>>,
+{
     #[inline]
     fn mul(&self, rhs: &Self, compiler: &mut Compiler<C>) -> Self {
         let _ = compiler;
@@ -380,8 +390,6 @@ where
     C: ProjectiveCurve,
     CV: CurveVar<C, ConstraintField<C>>,
 {
-    type Scalar = ScalarVar<C, CV>;
-
     #[inline]
     fn add(&self, rhs: &Self, compiler: &mut Compiler<C>) -> Self {
         let _ = compiler;
@@ -389,9 +397,17 @@ where
         result += &rhs.0;
         Self::new(result)
     }
+}
+
+impl<C, CV> algebra::ScalarMul<ScalarVar<C, CV>, Compiler<C>> for GroupVar<C, CV>
+where
+    C: ProjectiveCurve,
+    CV: CurveVar<C, ConstraintField<C>>,
+{
+    type Output = Self;
 
     #[inline]
-    fn mul(&self, scalar: &Self::Scalar, compiler: &mut Compiler<C>) -> Self {
+    fn scalar_mul(&self, scalar: &ScalarVar<C, CV>, compiler: &mut Compiler<C>) -> Self::Output {
         let _ = compiler;
         Self::new(
             self.0
diff --git a/manta-pay/src/crypto/poseidon/encryption.rs b/manta-pay/src/crypto/poseidon/encryption.rs
index c8f5faf09..887424a70 100644
--- a/manta-pay/src/crypto/poseidon/encryption.rs
+++ b/manta-pay/src/crypto/poseidon/encryption.rs
@@ -18,18 +18,38 @@
 
 use crate::crypto::poseidon::{Permutation, Specification, State};
 use alloc::{boxed::Box, vec::Vec};
-use core::{fmt::Debug, hash::Hash};
-use manta_crypto::permutation::{
-    duplex::{self, Setup, Types, Verify},
-    sponge::{Read, Write},
+use core::{fmt::Debug, hash::Hash, iter, ops::Deref, slice};
+use manta_crypto::{
+    constraint::{HasInput, Input},
+    eclair::{
+        self,
+        alloc::{
+            mode::{Public, Secret},
+            Allocate, Allocator, Constant, Var, Variable,
+        },
+        bool::{Assert, Bool},
+        num::Zero,
+        ops::BitAnd,
+        Has,
+    },
+    permutation::{
+        duplex::{self, Setup, Types, Verify},
+        sponge::{Read, Write},
+    },
+    rand::{Rand, RngCore, Sample},
+};
+use manta_util::{
+    codec::{self, Encode},
+    vec::padded_chunks_with,
+    BoxArray,
 };
-use manta_util::vec::padded_chunks;
 
 #[cfg(feature = "serde")]
 use manta_util::serde::{Deserialize, Serialize};
 
-/// Encryption Duplexer
-pub type Duplexer<S, COM> = duplex::Duplexer<Permutation<S, COM>, Encryption<S, COM>, COM>;
+/// Fixed Encryption Duplexer
+pub type FixedDuplexer<const N: usize, S, COM = ()> =
+    duplex::Duplexer<Permutation<S, COM>, FixedEncryption<N, S, COM>, COM>;
 
 /// Block Element
 pub trait BlockElement<COM = ()> {
@@ -80,19 +100,38 @@ where
     }
 }
 
+impl<S, COM> eclair::cmp::PartialEq<Self, COM> for SetupBlock<S, COM>
+where
+    COM: Has<bool>,
+    Bool<COM>: Constant<COM, Type = bool> + BitAnd<Bool<COM>, COM, Output = Bool<COM>>,
+    S: Specification<COM>,
+    S::Field: eclair::cmp::PartialEq<S::Field, COM>,
+{
+    #[inline]
+    fn eq(&self, rhs: &Self, compiler: &mut COM) -> Bool<COM> {
+        self.0.eq(&rhs.0, compiler)
+    }
+
+    #[inline]
+    fn assert_equal(&self, rhs: &Self, compiler: &mut COM)
+    where
+        COM: Assert,
+    {
+        self.0.assert_equal(&rhs.0, compiler)
+    }
+}
+
 /// Plaintext Block
+/* TODO:
 #[cfg_attr(
     feature = "serde",
     derive(Deserialize, Serialize),
-    serde(
-        bound(
-            deserialize = "S::Field: Deserialize<'de>",
-            serialize = "S::Field: Serialize"
-        ),
-        crate = "manta_util::serde",
-        deny_unknown_fields
-    )
+    serde(bound(
+        deserialize = "S::Field: Deserialize<'de>",
+        serialize = "S::Field: Serialize"
+    ),)
 )]
+*/
 #[derive(derivative::Derivative)]
 #[derivative(
     Clone(bound = "S::Field: Clone"),
@@ -101,7 +140,7 @@ where
     Hash(bound = "S::Field: Hash"),
     PartialEq(bound = "S::Field: PartialEq")
 )]
-pub struct PlaintextBlock<S, COM = ()>(Box<[S::Field]>)
+pub struct PlaintextBlock<S, COM = ()>(pub Box<[S::Field]>)
 where
     S: Specification<COM>;
 
@@ -121,7 +160,79 @@ where
     }
 }
 
+impl<S, COM> eclair::cmp::PartialEq<Self, COM> for PlaintextBlock<S, COM>
+where
+    COM: Has<bool>,
+    Bool<COM>: Constant<COM, Type = bool> + BitAnd<Bool<COM>, COM, Output = Bool<COM>>,
+    S: Specification<COM>,
+    S::Field: eclair::cmp::PartialEq<S::Field, COM>,
+{
+    #[inline]
+    fn eq(&self, rhs: &Self, compiler: &mut COM) -> Bool<COM> {
+        self.0.eq(&rhs.0, compiler)
+    }
+
+    #[inline]
+    fn assert_equal(&self, rhs: &Self, compiler: &mut COM)
+    where
+        COM: Assert,
+    {
+        self.0.assert_equal(&rhs.0, compiler)
+    }
+}
+
+impl<S, COM> Variable<Secret, COM> for PlaintextBlock<S, COM>
+where
+    S: Specification<COM> + Constant<COM>,
+    S::Field: Variable<Public, COM>,
+    S::Type: Specification<Field = Var<S::Field, Public, COM>>,
+{
+    type Type = PlaintextBlock<S::Type>;
+
+    #[inline]
+    fn new_unknown(compiler: &mut COM) -> Self {
+        Self(
+            iter::repeat_with(|| compiler.allocate_unknown())
+                .take(S::WIDTH - 1)
+                .collect(),
+        )
+    }
+
+    #[inline]
+    fn new_known(this: &Self::Type, compiler: &mut COM) -> Self {
+        Self(this.0.iter().map(|this| this.as_known(compiler)).collect())
+    }
+}
+
+impl<S> Encode for PlaintextBlock<S>
+where
+    S: Specification,
+    S::Field: Encode,
+{
+    #[inline]
+    fn encode<W>(&self, writer: W) -> Result<(), W::Error>
+    where
+        W: codec::Write,
+    {
+        self.0.encode(writer)
+    }
+}
+
+impl<S, P> Input<P> for PlaintextBlock<S>
+where
+    S: Specification,
+    P: HasInput<S::Field> + ?Sized,
+{
+    #[inline]
+    fn extend(&self, input: &mut P::Input) {
+        for element in self.0.iter() {
+            P::extend(input, element);
+        }
+    }
+}
+
 /// Ciphertext Block
+/* TODO:
 #[cfg_attr(
     feature = "serde",
     derive(Deserialize, Serialize),
@@ -134,6 +245,7 @@ where
         deny_unknown_fields
     )
 )]
+*/
 #[derive(derivative::Derivative)]
 #[derivative(
     Clone(bound = "S::Field: Clone"),
@@ -142,7 +254,7 @@ where
     Hash(bound = "S::Field: Hash"),
     PartialEq(bound = "S::Field: PartialEq")
 )]
-pub struct CiphertextBlock<S, COM = ()>(Box<[S::Field]>)
+pub struct CiphertextBlock<S, COM = ()>(pub Box<[S::Field]>)
 where
     S: Specification<COM>;
 
@@ -162,7 +274,187 @@ where
     }
 }
 
+impl<S, COM> eclair::cmp::PartialEq<Self, COM> for CiphertextBlock<S, COM>
+where
+    COM: Has<bool>,
+    Bool<COM>: Constant<COM, Type = bool> + BitAnd<Bool<COM>, COM, Output = Bool<COM>>,
+    S: Specification<COM>,
+    S::Field: eclair::cmp::PartialEq<S::Field, COM>,
+{
+    #[inline]
+    fn eq(&self, rhs: &Self, compiler: &mut COM) -> Bool<COM> {
+        self.0.eq(&rhs.0, compiler)
+    }
+
+    #[inline]
+    fn assert_equal(&self, rhs: &Self, compiler: &mut COM)
+    where
+        COM: Assert,
+    {
+        self.0.assert_equal(&rhs.0, compiler)
+    }
+}
+
+impl<S, COM> Variable<Public, COM> for CiphertextBlock<S, COM>
+where
+    S: Specification<COM> + Constant<COM>,
+    S::Field: Variable<Public, COM>,
+    S::Type: Specification<Field = Var<S::Field, Public, COM>>,
+{
+    type Type = CiphertextBlock<S::Type>;
+
+    #[inline]
+    fn new_unknown(compiler: &mut COM) -> Self {
+        Self(
+            iter::repeat_with(|| compiler.allocate_unknown())
+                .take(S::WIDTH - 1)
+                .collect(),
+        )
+    }
+
+    #[inline]
+    fn new_known(this: &Self::Type, compiler: &mut COM) -> Self {
+        Self(this.0.iter().map(|this| this.as_known(compiler)).collect())
+    }
+}
+
+impl<S> Encode for CiphertextBlock<S>
+where
+    S: Specification,
+    S::Field: Encode,
+{
+    #[inline]
+    fn encode<W>(&self, writer: W) -> Result<(), W::Error>
+    where
+        W: codec::Write,
+    {
+        self.0.encode(writer)
+    }
+}
+
+impl<S, P> Input<P> for CiphertextBlock<S>
+where
+    S: Specification,
+    P: HasInput<S::Field> + ?Sized,
+{
+    #[inline]
+    fn extend(&self, input: &mut P::Input) {
+        for element in self.0.iter() {
+            P::extend(input, element);
+        }
+    }
+}
+
+/// Block Array
+#[derive(derivative::Derivative)]
+#[derivative(
+    Clone(bound = "B: Clone"),
+    Debug(bound = "B: Debug"),
+    Eq(bound = "B: Eq"),
+    Hash(bound = "B: Hash"),
+    PartialEq(bound = "B: PartialEq")
+)]
+pub struct BlockArray<B, const N: usize>(pub BoxArray<B, N>);
+
+impl<B, const N: usize> Deref for BlockArray<B, N> {
+    type Target = BoxArray<B, N>;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<B, const N: usize> FromIterator<B> for BlockArray<B, N> {
+    #[inline]
+    fn from_iter<I>(iter: I) -> Self
+    where
+        I: IntoIterator<Item = B>,
+    {
+        Self(iter.into_iter().collect())
+    }
+}
+
+impl<'b, B, const N: usize> IntoIterator for &'b BlockArray<B, N> {
+    type Item = &'b B;
+    type IntoIter = slice::Iter<'b, B>;
+
+    #[inline]
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.iter()
+    }
+}
+
+impl<B, const N: usize> Encode for BlockArray<B, N>
+where
+    B: Encode,
+{
+    #[inline]
+    fn encode<W>(&self, writer: W) -> Result<(), W::Error>
+    where
+        W: codec::Write,
+    {
+        self.0.encode(writer)
+    }
+}
+
+impl<B, const N: usize, P> Input<P> for BlockArray<B, N>
+where
+    P: HasInput<B> + ?Sized,
+{
+    #[inline]
+    fn extend(&self, input: &mut P::Input) {
+        for block in &self.0 {
+            P::extend(input, block);
+        }
+    }
+}
+
+impl<B, const N: usize, COM> eclair::cmp::PartialEq<Self, COM> for BlockArray<B, N>
+where
+    COM: Has<bool>,
+    Bool<COM>: Constant<COM, Type = bool> + BitAnd<Bool<COM>, COM, Output = Bool<COM>>,
+    B: eclair::cmp::PartialEq<B, COM>,
+{
+    #[inline]
+    fn eq(&self, rhs: &Self, compiler: &mut COM) -> Bool<COM> {
+        self.0.eq(&rhs.0, compiler)
+    }
+
+    #[inline]
+    fn assert_equal(&self, rhs: &Self, compiler: &mut COM)
+    where
+        COM: Assert,
+    {
+        self.0.assert_equal(&rhs.0, compiler)
+    }
+}
+
+impl<B, const N: usize, M, COM> Variable<M, COM> for BlockArray<B, N>
+where
+    B: Variable<M, COM>,
+{
+    type Type = BlockArray<B::Type, N>;
+
+    #[inline]
+    fn new_unknown(compiler: &mut COM) -> Self {
+        Self(compiler.allocate_unknown())
+    }
+
+    #[inline]
+    fn new_known(this: &Self::Type, compiler: &mut COM) -> Self {
+        Self(this.0.as_known(compiler))
+    }
+}
+
+/// Fixed Plaintext Type
+pub type FixedPlaintext<const N: usize, S, COM = ()> = BlockArray<PlaintextBlock<S, COM>, N>;
+
+/// Fixed Ciphertext Type
+pub type FixedCiphertext<const N: usize, S, COM = ()> = BlockArray<CiphertextBlock<S, COM>, N>;
+
 /// Authentication Tag
+/* TODO:
 #[cfg_attr(
     feature = "serde",
     derive(Deserialize, Serialize),
@@ -175,6 +467,7 @@ where
         deny_unknown_fields
     )
 )]
+*/
 #[derive(derivative::Derivative)]
 #[derivative(
     Clone(bound = "S::Field: Clone"),
@@ -183,7 +476,7 @@ where
     Hash(bound = "S::Field: Hash"),
     PartialEq(bound = "S::Field: PartialEq")
 )]
-pub struct Tag<S, COM = ()>(S::Field)
+pub struct Tag<S, COM = ()>(pub S::Field)
 where
     S: Specification<COM>;
 
@@ -199,7 +492,64 @@ where
     }
 }
 
-/// Encryption Configuration
+impl<S, COM> eclair::cmp::PartialEq<Self, COM> for Tag<S, COM>
+where
+    COM: Has<bool>,
+    S: Specification<COM>,
+    S::Field: eclair::cmp::PartialEq<S::Field, COM>,
+{
+    #[inline]
+    fn eq(&self, rhs: &Self, compiler: &mut COM) -> Bool<COM> {
+        self.0.eq(&rhs.0, compiler)
+    }
+}
+
+impl<S, COM> Variable<Public, COM> for Tag<S, COM>
+where
+    S: Specification<COM> + Constant<COM>,
+    S::Field: Variable<Public, COM>,
+    S::Type: Specification<Field = Var<S::Field, Public, COM>>,
+{
+    type Type = Tag<S::Type>;
+
+    #[inline]
+    fn new_unknown(compiler: &mut COM) -> Self {
+        Self(compiler.allocate_unknown())
+    }
+
+    #[inline]
+    fn new_known(this: &Self::Type, compiler: &mut COM) -> Self {
+        Self(this.0.as_known(compiler))
+    }
+}
+
+impl<S> Encode for Tag<S>
+where
+    S: Specification,
+    S::Field: Encode,
+{
+    #[inline]
+    fn encode<W>(&self, writer: W) -> Result<(), W::Error>
+    where
+        W: codec::Write,
+    {
+        self.0.encode(writer)
+    }
+}
+
+impl<S, P> Input<P> for Tag<S>
+where
+    S: Specification,
+    P: HasInput<S::Field> + ?Sized,
+{
+    #[inline]
+    fn extend(&self, input: &mut P::Input) {
+        P::extend(input, &self.0)
+    }
+}
+
+/// Fixed Encryption Configuration
+/* TODO:
 #[cfg_attr(
     feature = "serde",
     derive(Deserialize, Serialize),
@@ -212,6 +562,7 @@ where
         deny_unknown_fields
     )
 )]
+*/
 #[derive(derivative::Derivative)]
 #[derivative(
     Clone(bound = "S::Field: Clone"),
@@ -220,7 +571,7 @@ where
     Hash(bound = "S::Field: Hash"),
     PartialEq(bound = "S::Field: PartialEq")
 )]
-pub struct Encryption<S, COM = ()>
+pub struct FixedEncryption<const N: usize, S, COM = ()>
 where
     S: Specification<COM>,
 {
@@ -228,7 +579,39 @@ where
     pub initial_state: State<S, COM>,
 }
 
-impl<S, COM> Types<Permutation<S, COM>, COM> for Encryption<S, COM>
+impl<const N: usize, S, COM> Constant<COM> for FixedEncryption<N, S, COM>
+where
+    S: Specification<COM> + Constant<COM>,
+    S::Type: Specification,
+    State<S, COM>: Constant<COM, Type = State<S::Type>>,
+{
+    type Type = FixedEncryption<N, S::Type>;
+
+    #[inline]
+    fn new_constant(this: &Self::Type, compiler: &mut COM) -> Self {
+        Self {
+            initial_state: this.initial_state.as_constant(compiler),
+        }
+    }
+}
+
+impl<const N: usize, S, D> Sample<D> for FixedEncryption<N, S>
+where
+    S: Specification,
+    State<S>: Sample<D>,
+{
+    #[inline]
+    fn sample<R>(distribution: D, rng: &mut R) -> Self
+    where
+        R: RngCore + ?Sized,
+    {
+        Self {
+            initial_state: rng.sample(distribution),
+        }
+    }
+}
+
+impl<const N: usize, S, COM> Types<Permutation<S, COM>, COM> for FixedEncryption<N, S, COM>
 where
     S: Specification<COM>,
     S::Field: Clone + BlockElement<COM>,
@@ -237,14 +620,16 @@ where
     type Header = Vec<S::Field>;
     type SetupBlock = SetupBlock<S, COM>;
     type PlaintextBlock = PlaintextBlock<S, COM>;
+    type Plaintext = FixedPlaintext<N, S, COM>;
     type CiphertextBlock = CiphertextBlock<S, COM>;
+    type Ciphertext = FixedCiphertext<N, S, COM>;
     type Tag = Tag<S, COM>;
 }
 
-impl<S, COM> Setup<Permutation<S, COM>, COM> for Encryption<S, COM>
+impl<const N: usize, S, COM> Setup<Permutation<S, COM>, COM> for FixedEncryption<N, S, COM>
 where
     S: Specification<COM>,
-    S::Field: Clone + Default + BlockElement<COM>,
+    S::Field: Clone + BlockElement<COM> + Zero<COM>,
 {
     #[inline]
     fn initialize(&self, compiler: &mut COM) -> State<S, COM> {
@@ -259,9 +644,10 @@ where
         header: &Self::Header,
         compiler: &mut COM,
     ) -> Vec<Self::SetupBlock> {
-        let _ = compiler;
-        let mut blocks = padded_chunks(key.as_slice(), S::WIDTH - 1);
-        blocks.extend(padded_chunks(header.as_slice(), S::WIDTH - 1));
+        let mut blocks = padded_chunks_with(key.as_slice(), S::WIDTH - 1, || Zero::zero(compiler));
+        blocks.extend(padded_chunks_with(header.as_slice(), S::WIDTH - 1, || {
+            Zero::zero(compiler)
+        }));
         blocks
             .into_iter()
             .map(|b| SetupBlock(b.into_boxed_slice()))
@@ -269,7 +655,7 @@ where
     }
 }
 
-impl<S> Verify<Permutation<S>> for Encryption<S>
+impl<const N: usize, S> Verify<Permutation<S>> for FixedEncryption<N, S>
 where
     S: Specification,
     S::Field: Clone + PartialEq + BlockElement,
diff --git a/manta-util/Cargo.toml b/manta-util/Cargo.toml
index 2e79d5c52..f60895db1 100644
--- a/manta-util/Cargo.toml
+++ b/manta-util/Cargo.toml
@@ -41,7 +41,7 @@ std = ["alloc"]
 crossbeam-channel = { version = "0.5.6", optional = true, default-features = false }
 rayon = { version = "1.5.3", optional = true, default-features = false }
 reqwest = { version = "0.11.11", optional = true, default-features = false, features = ["json"] }
-serde = { version = "1.0.140", optional = true, default-features = false, features = ["derive"] }
+serde = { version = "1.0.144", optional = true, default-features = false, features = ["derive"] }
 serde_with = { version = "1.14.0", optional = true, default-features = false, features = ["macros"] }
 tide = { version = "0.16.0", optional = true, default-features = false }
 workspace-hack = { version = "0.1.0", path = "../workspace-hack" }
diff --git a/manta-util/src/bytes.rs b/manta-util/src/bytes.rs
index d748f465a..592bc0c98 100644
--- a/manta-util/src/bytes.rs
+++ b/manta-util/src/bytes.rs
@@ -16,6 +16,15 @@
 
 //! Utilities for Manipulating Bytes
 
+#[cfg(feature = "alloc")]
+use alloc::vec::Vec;
+
+/// Counts the number of bytes required to encode a number with the given number of `bits`.
+#[inline]
+pub const fn byte_count(bits: u32) -> u32 {
+    (bits / 8) + (((bits % 8) != 0) as u32)
+}
+
 /// Size Limit
 pub trait SizeLimit {
     /// Maximum Number of Bytes Required to Represent [`Self`]
@@ -90,8 +99,10 @@ impl<const N: usize> IntoBytes<N> for [u8; N] {
     }
 }
 
-/// Counts the number of bytes required to encode a number with the given number of `bits`.
-#[inline]
-pub const fn byte_count(bits: u32) -> u32 {
-    (bits / 8) + (((bits % 8) != 0) as u32)
+/// Byte Vector Conversion
+#[cfg(feature = "alloc")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
+pub trait AsBytes {
+    /// Returns an owned byte representation of `self`.
+    fn as_bytes(&self) -> Vec<u8>;
 }
diff --git a/manta-util/src/cmp.rs b/manta-util/src/cmp.rs
new file mode 100644
index 000000000..ebedf20d4
--- /dev/null
+++ b/manta-util/src/cmp.rs
@@ -0,0 +1,76 @@
+// Copyright 2019-2022 Manta Network.
+// This file is part of manta-rs.
+//
+// manta-rs is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// manta-rs is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with manta-rs.  If not, see <http://www.gnu.org/licenses/>.
+
+//! Comparison Utilities
+
+/// Independence Context
+pub trait IndependenceContext {
+    /// Default Independence Value
+    const DEFAULT: bool;
+}
+
+/// Default True
+#[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct DefaultTrue;
+
+impl IndependenceContext for DefaultTrue {
+    const DEFAULT: bool = true;
+}
+
+/// Default False
+#[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct DefaultFalse;
+
+impl IndependenceContext for DefaultFalse {
+    const DEFAULT: bool = false;
+}
+
+/// Independence Relation
+pub trait Independence<C>
+where
+    C: IndependenceContext + ?Sized,
+{
+    /// Determines if `fst` and `snd` are independent.
+    ///
+    /// # Implementation Note
+    ///
+    /// By default two values are given the independence value [`C::DEFAULT`] as specified on the
+    /// `trait` parameter.
+    ///
+    /// [`C::DEFAULT`]: IndependenceContext::DEFAULT
+    #[inline]
+    fn is_independent(&self, rhs: &Self) -> bool {
+        let _ = rhs;
+        C::DEFAULT
+    }
+
+    /// Returns the negation of the [`is_independent`](Self::is_independent) method.
+    #[inline]
+    fn is_related(&self, rhs: &Self) -> bool {
+        !self.is_independent(rhs)
+    }
+}
+
+impl<C, T> Independence<C> for &T
+where
+    C: IndependenceContext + ?Sized,
+    T: Independence<C> + ?Sized,
+{
+    #[inline]
+    fn is_independent(&self, rhs: &Self) -> bool {
+        (*self).is_independent(rhs)
+    }
+}
diff --git a/manta-util/src/codec.rs b/manta-util/src/codec.rs
index df0122322..75052de8d 100644
--- a/manta-util/src/codec.rs
+++ b/manta-util/src/codec.rs
@@ -21,7 +21,7 @@
 use core::{convert::Infallible, fmt::Debug, hash::Hash, marker::PhantomData};
 
 #[cfg(feature = "alloc")]
-use {crate::into_array_unchecked, alloc::vec::Vec};
+use crate::{into_array_unchecked, vec::Vec};
 
 /// Implements [`Decode`] and [`Encode`] for a type with no data that implements [`Default`].
 #[macro_export]
@@ -587,51 +587,54 @@ impl<T> Encode for PhantomData<T> {
     }
 }
 
-impl Encode for u8 {
+impl Encode for bool {
     #[inline]
-    fn encode<W>(&self, mut writer: W) -> Result<(), W::Error>
+    fn encode<W>(&self, writer: W) -> Result<(), W::Error>
     where
         W: Write,
     {
-        writer.write_ref(&[*self])?;
-        Ok(())
+        (*self as u8).encode(writer)
     }
 }
 
-impl Encode for u16 {
-    #[inline]
-    fn encode<W>(&self, mut writer: W) -> Result<(), W::Error>
-    where
-        W: Write,
-    {
-        writer.write_ref(&self.to_le_bytes())?;
-        Ok(())
+/// Defines an [`Encode`] implemention for the given integer type `$type`.
+macro_rules! encode_int {
+    ($($type:tt),* $(,)?) => {
+        $(
+            impl Encode for $type {
+                #[inline]
+                fn encode<W>(&self, mut writer: W) -> Result<(), W::Error>
+                where
+                    W: Write,
+                {
+                    writer.write_ref(&self.to_le_bytes())?;
+                    Ok(())
+                }
+            }
+        )*
     }
 }
 
-impl Encode for u32 {
-    #[inline]
-    fn encode<W>(&self, mut writer: W) -> Result<(), W::Error>
-    where
-        W: Write,
-    {
-        writer.write_ref(&self.to_le_bytes())?;
-        Ok(())
-    }
-}
+encode_int!(u8, i8, u16, i16, u32, i32, u64, i64, u128, i128);
 
-impl Encode for u64 {
+impl<T> Encode for [T]
+where
+    T: Encode,
+{
     #[inline]
     fn encode<W>(&self, mut writer: W) -> Result<(), W::Error>
     where
         W: Write,
     {
-        writer.write_ref(&self.to_le_bytes())?;
+        (self.len() as u64).encode(&mut writer)?;
+        for item in self {
+            item.encode(&mut writer)?;
+        }
         Ok(())
     }
 }
 
-impl<T> Encode for [T]
+impl<T, const N: usize> Encode for [T; N]
 where
     T: Encode,
 {
@@ -640,7 +643,6 @@ where
     where
         W: Write,
     {
-        (self.len() as u64).encode(&mut writer)?;
         for item in self {
             item.encode(&mut writer)?;
         }
@@ -648,7 +650,9 @@ where
     }
 }
 
-impl<T, const N: usize> Encode for [T; N]
+#[cfg(feature = "alloc")]
+#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
+impl<T> Encode for Vec<T>
 where
     T: Encode,
 {
@@ -657,6 +661,7 @@ where
     where
         W: Write,
     {
+        (self.len() as u64).encode(&mut writer)?;
         for item in self {
             item.encode(&mut writer)?;
         }
diff --git a/manta-util/src/convert.rs b/manta-util/src/convert.rs
index 9bf1e7559..701163b4a 100644
--- a/manta-util/src/convert.rs
+++ b/manta-util/src/convert.rs
@@ -38,3 +38,21 @@ pub fn never_err<T>(result: Result<T, Never>) -> T {
         Err(err) => never(err),
     }
 }
+
+/// Structure Field
+pub trait Field<T> {
+    /// Returns a shared reference to the field value.
+    fn get(&self) -> &T;
+
+    /// Returns a mutable reference to the field value.
+    fn get_mut(&mut self) -> &mut T;
+
+    /// Converts `self` into the field value, dropping the rest of the structure.
+    fn into(self) -> T;
+}
+
+/// Enumeration Variant
+pub trait Variant<T> {
+    /// Constructs the value of the enumeration of the given `variant`.
+    fn from(variant: T) -> Self;
+}
diff --git a/manta-util/src/iter/mod.rs b/manta-util/src/iter/mod.rs
index 6222ae374..4c8ffc6eb 100644
--- a/manta-util/src/iter/mod.rs
+++ b/manta-util/src/iter/mod.rs
@@ -16,7 +16,7 @@
 
 //! Iteration Utilities
 
-use crate::IsType;
+use core::iter::Map;
 
 #[cfg(feature = "serde")]
 use crate::serde::{Deserialize, Serialize};
@@ -113,18 +113,124 @@ impl<I> IteratorExt for I where I: Iterator {}
 
 /// Borrowing Iterator Trait
 pub trait IterRef<'i, I = &'i Self> {
+    /// Borrowed Item Type
+    type Item;
+
+    /// Iterator Type
+    type IntoIter: Iterator<Item = Self::Item>;
+
     /// Borrowing Iterator Type
-    type Iterator: IntoIterator + IsType<Type = I>;
+    type Iter: IntoIterator<Item = Self::Item, IntoIter = Self::IntoIter>;
+
+    /// Converts `this` into the iterator type.
+    fn iter(this: I) -> Self::Iter;
+}
+
+impl<'i, I> IterRef<'i> for I
+where
+    I: ?Sized,
+    for<'t> &'t Self: IntoIterator,
+{
+    type Item = <&'i Self as IntoIterator>::Item;
+    type IntoIter = <&'i Self as IntoIterator>::IntoIter;
+    type Iter = &'i Self;
+
+    #[inline]
+    fn iter(this: &'i Self) -> Self::Iter {
+        this
+    }
+}
+
+/// Item Type for [`IterRef`]
+pub type RefItem<'t, T> = <T as IterRef<'t, &'t T>>::Item;
+
+/// Borrowing Iterator Type for [`IterRef`]
+pub type RefIter<'t, T> = <T as IterRef<'t, &'t T>>::Iter;
+
+/// Exact Size Iteration Type
+pub trait ExactSizeIterRef<'i, I = &'i Self> {
+    /// Item Type
+    type Item;
+
+    /// Iterator Type
+    type IntoIter: ExactSizeIterator<Item = Self::Item>;
+}
+
+impl<'i, I> ExactSizeIterRef<'i> for I
+where
+    for<'t> &'t Self: IntoIterator,
+    <&'i Self as IntoIterator>::IntoIter: ExactSizeIterator,
+{
+    type Item = <&'i Self as IntoIterator>::Item;
+    type IntoIter = <&'i Self as IntoIterator>::IntoIter;
 }
 
 /// Iterable Type
 ///
 /// This `trait` is implemented for any type that has a borrowing [`IntoIterator`] implementation
 /// for any reference of that type.
-pub trait Iterable: for<'i> IterRef<'i> {}
+pub trait Iterable: for<'i> IterRef<'i> {
+    /// Returns the iterator for `self`.
+    #[inline]
+    fn iter(&self) -> <RefIter<Self> as IntoIterator>::IntoIter {
+        <Self as IterRef<'_>>::iter(self).into_iter()
+    }
+
+    /// Returns the converting iterator for `self`.
+    #[inline]
+    fn convert_iter<'t, T>(&'t self) -> ConvertItemRefMap<'t, T, Self>
+    where
+        Self: ConvertItemRef<'t, T, Item = RefItem<'t, Self>>,
+    {
+        self.iter().map(|item| Self::convert_item(item))
+    }
+}
 
 impl<T> Iterable for T where T: for<'i> IterRef<'i> + ?Sized {}
 
+/// Exact Size Iterable
+pub trait ExactSizeIterable:
+    for<'i> IterRef<'i, IntoIter = <Self as ExactSizeIterRef<'i>>::IntoIter>
+    + for<'i> ExactSizeIterRef<'i, Item = RefItem<'i, Self>>
+{
+}
+
+impl<I> ExactSizeIterable for I where
+    I: for<'i> IterRef<'i, IntoIter = <Self as ExactSizeIterRef<'i>>::IntoIter>
+        + for<'i> ExactSizeIterRef<'i, Item = RefItem<'i, Self>>
+{
+}
+
+/// [`ConvertItemRef`] Map Type
+pub type ConvertItemRefMap<'t, T, I> =
+    Map<<RefIter<'t, I> as IntoIterator>::IntoIter, fn(RefItem<'t, I>) -> T>;
+
+/// Item Type Converter
+pub trait ConvertItemRef<'i, T, I = &'i Self> {
+    /// Item Type
+    type Item: Into<T>;
+
+    /// Converts `item` into an element of type `T`.
+    #[inline]
+    fn convert_item(item: Self::Item) -> T {
+        item.into()
+    }
+}
+
+impl<'i, T, I> ConvertItemRef<'i, T> for I
+where
+    I: ?Sized,
+    for<'t> &'t Self: IntoIterator,
+    <&'i Self as IntoIterator>::Item: Into<T>,
+{
+    type Item = <&'i Self as IntoIterator>::Item;
+}
+
+/// Borrow Iterator
+pub trait BorrowIterator<T>: for<'i> IterRef<'i, Item = &'i T> {}
+
+impl<T, I> BorrowIterator<T> for I where I: for<'i> IterRef<'i, Item = &'i T> {}
+
 /// For-Each Collector
 ///
 /// In the same way that `() : FromIterator<()>` which just calls [`Iterator::for_each`] internally,
diff --git a/manta-util/src/lib.rs b/manta-util/src/lib.rs
index 4ddef5d11..b9a4e09b3 100644
--- a/manta-util/src/lib.rs
+++ b/manta-util/src/lib.rs
@@ -29,6 +29,7 @@ mod bytes;
 mod macros;
 mod sealed;
 
+pub mod cmp;
 pub mod codec;
 pub mod convert;
 pub mod future;
diff --git a/workspace-hack/Cargo.toml b/workspace-hack/Cargo.toml
index e6fdfced8..3c92e6620 100644
--- a/workspace-hack/Cargo.toml
+++ b/workspace-hack/Cargo.toml
@@ -15,10 +15,11 @@ publish = false
 ### BEGIN HAKARI SECTION
 [dependencies]
 aes-gcm = { version = "0.9.4", features = ["aes", "alloc"] }
-anyhow = { version = "1.0.61", features = ["std"] }
+anyhow = { version = "1.0.62", features = ["std"] }
 ark-serialize = { version = "0.3.0", default-features = false, features = ["ark-serialize-derive", "derive"] }
 bitflags = { version = "1.3.2" }
 blake3 = { version = "1.3.1", default-features = false, features = ["digest", "std"] }
+block-buffer = { version = "0.9.0", default-features = false, features = ["block-padding"] }
 byteorder = { version = "1.4.3", features = ["std"] }
 crypto-common = { version = "0.1.6", default-features = false, features = ["std"] }
 digest-93f6ce9d446188ac = { package = "digest", version = "0.10.3", features = ["alloc", "block-buffer", "core-api", "mac", "std", "subtle"] }
@@ -36,12 +37,13 @@ indexmap = { version = "1.9.1", default-features = false, features = ["std"] }
 log = { version = "0.4.17", default-features = false, features = ["kv_unstable", "kv_unstable_std", "std", "value-bag"] }
 memchr = { version = "2.5.0", features = ["std"] }
 num-traits = { version = "0.2.15", features = ["i128", "libm", "std"] }
+pbkdf2 = { version = "0.9.0", default-features = false, features = ["hmac", "sha2"] }
 ppv-lite86 = { version = "0.2.16", default-features = false, features = ["simd", "std"] }
 rand = { version = "0.8.5", features = ["alloc", "getrandom", "libc", "rand_chacha", "std", "std_rng"] }
 rand_chacha = { version = "0.3.1", default-features = false, features = ["std"] }
 rand_core = { version = "0.6.3", default-features = false, features = ["alloc", "getrandom", "std"] }
-serde = { version = "1.0.143", features = ["alloc", "derive", "serde_derive", "std"] }
-serde_json = { version = "1.0.83", features = ["alloc", "std"] }
+serde = { version = "1.0.144", features = ["alloc", "derive", "serde_derive", "std"] }
+serde_json = { version = "1.0.85", features = ["alloc", "std"] }
 sha2 = { version = "0.9.9", features = ["std"] }
 standback = { version = "0.2.17", default-features = false, features = ["std"] }
 subtle = { version = "2.4.1", default-features = false, features = ["i128"] }
@@ -51,7 +53,7 @@ web-sys = { version = "0.3.59", default-features = false, features = ["BinaryTyp
 zeroize = { version = "1.5.7", default-features = false, features = ["alloc", "zeroize_derive"] }
 
 [build-dependencies]
-anyhow = { version = "1.0.61", features = ["std"] }
+anyhow = { version = "1.0.62", features = ["std"] }
 blake3 = { version = "1.3.1", default-features = false, features = ["digest", "std"] }
 cc = { version = "1.0.73", default-features = false, features = ["jobserver", "parallel"] }
 crypto-common = { version = "0.1.6", default-features = false, features = ["std"] }
@@ -59,7 +61,7 @@ digest-93f6ce9d446188ac = { package = "digest", version = "0.10.3", features = [
 generic-array = { version = "0.14.6", default-features = false, features = ["more_lengths"] }
 log = { version = "0.4.17", default-features = false, features = ["kv_unstable", "kv_unstable_std", "std", "value-bag"] }
 num-traits = { version = "0.2.15", features = ["i128", "libm", "std"] }
-serde = { version = "1.0.143", features = ["alloc", "derive", "serde_derive", "std"] }
+serde = { version = "1.0.144", features = ["alloc", "derive", "serde_derive", "std"] }
 standback = { version = "0.2.17", default-features = false, features = ["std"] }
 subtle = { version = "2.4.1", default-features = false, features = ["i128"] }
 syn = { version = "1.0.99", features = ["clone-impls", "derive", "extra-traits", "fold", "full", "parsing", "printing", "proc-macro", "quote", "visit", "visit-mut"] }