distinguish implementations based on feature flag

light-client-verifier/Cargo.toml

@@ -24,7 +24,7 @@ rustdoc-args = ["--cfg", "docsrs"]
 
 [features]
 default = ["flex-error/std", "flex-error/eyre_tracer"]
-
+rust-crypto = []
 [dependencies]
 tendermint = { version = "0.26.0", path = "../tendermint", default-features = false }
 

light-client-verifier/src/operations/commit_validator.rs

@@ -3,6 +3,8 @@
 use core::marker::PhantomData;
 
 use tendermint::block::CommitSig;
+#[cfg(feature = "rust-crypto")]
+use tendermint::crypto::DefaultHostFunctionsManager;
 
 use crate::{
     errors::VerificationError,
@@ -79,7 +81,7 @@ impl<C> CommitValidator<C> {
 /// The batteries-included validator, for when you don't mind the dependencies on
 /// the full rust-crypto stack.
 #[cfg(feature = "rust-crypto")]
-pub type ProdCommitValidator = CommitValidator<RustCryptoProvider>;
+pub type ProdCommitValidator = CommitValidator<DefaultHostFunctionsManager>;
 
 #[cfg(not(feature = "rust-crypto"))]
 /// Production-ready implementation of a commit validator
@@ -88,11 +90,21 @@ pub struct ProdCommitValidator<C> {
     inner: CommitValidator<C>,
 }
 
+#[cfg(not(feature = "rust-crypto"))]
 impl<C> AsRef<CommitValidator<C>> for ProdCommitValidator<C> {
     fn as_ref(&self) -> &CommitValidator<C> {
         &self.inner
     }
 }
+
+#[cfg(feature = "rust-crypto")]
+impl AsRef<CommitValidator<DefaultHostFunctionsManager>> for ProdCommitValidator {
+    fn as_ref(&self) -> &CommitValidator<DefaultHostFunctionsManager> {
+        self
+    }
+}
+
+#[cfg(not(feature = "rust-crypto"))]
 impl<C> ProdCommitValidator<C> {
     /// Create a new commit validator using the given [`Hasher`]
     /// to compute the hash of headers and validator sets.
@@ -106,8 +118,28 @@ impl<C> ProdCommitValidator<C> {
     }
 }
 
+#[cfg(feature = "rust-crypto")]
+impl ProdCommitValidator {
+    /// Create a new commit validator using the given [`Hasher`]
+    /// to compute the hash of headers and validator sets.
+    pub fn new(hasher: ProdHasher) -> Self {
+        CommitValidator {
+            hasher,
+            _c: PhantomData::default(),
+        }
+    }
+}
+
+#[cfg(not(feature = "rust-crypto"))]
 impl<C> Default for ProdCommitValidator<C> {
     fn default() -> Self {
         Self::new(ProdHasher::default())
     }
 }
+
+#[cfg(feature = "rust-crypto")]
+impl Default for ProdCommitValidator {
+    fn default() -> Self {
+        Self::new(ProdHasher::default())
+    }
+}

light-client-verifier/src/predicates.rs

@@ -86,6 +86,7 @@ pub trait VerificationPredicates: Send + Sync {
         }
     }
 
+    #[cfg(not(feature = "rust-crypto"))]
     /// Validate the commit using the given commit validator.
     fn valid_commit(
         &self,
@@ -99,6 +100,20 @@ pub trait VerificationPredicates: Send + Sync {
         Ok(())
     }
 
+    #[cfg(feature = "rust-crypto")]
+    /// Validate the commit using the given commit validator.
+    fn valid_commit(
+        &self,
+        signed_header: &SignedHeader,
+        validators: &ValidatorSet,
+        commit_validator: &CommitValidator<DefaultHostFunctionsManager>,
+    ) -> Result<(), VerificationError> {
+        commit_validator.validate(signed_header, validators)?;
+        commit_validator.validate_full(signed_header, validators)?;
+
+        Ok(())
+    }
+
     /// Check that the trusted header is within the trusting period, adjusting for clock drift.
     fn is_within_trust_period(
         &self,

light-client-verifier/src/verifier.rs

@@ -1,5 +1,8 @@
 //! Provides an interface and default implementation of the `Verifier` component
 
+#[cfg(feature = "rust-crypto")]
+use core::marker::PhantomData;
+
 use preds::{ProdPredicates, VerificationPredicates};
 use serde::{Deserialize, Serialize};
 use tendermint::crypto::{CryptoProvider, DefaultHostFunctionsManager};
@@ -69,6 +72,7 @@ macro_rules! verdict {
     };
 }
 
+#[cfg(not(feature = "rust-crypto"))]
 /// Predicate verifier encapsulating components necessary to facilitate
 /// verification.
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -78,7 +82,19 @@ pub struct PredicateVerifier<P, C, H, CP> {
     commit_validator: ProdCommitValidator<CP>,
     hasher: H,
 }
+#[cfg(feature = "rust-crypto")]
+/// Predicate verifier encapsulating components necessary to facilitate
+/// verification.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct PredicateVerifier<P, C, H, CP> {
+    predicates: P,
+    voting_power_calculator: C,
+    commit_validator: ProdCommitValidator,
+    hasher: H,
+    _p: PhantomData<CP>,
+}
 
+#[cfg(not(feature = "rust-crypto"))]
 impl<P, C, H, CP> Default for PredicateVerifier<P, C, H, CP>
 where
     P: Default,
@@ -96,6 +112,25 @@ where
     }
 }
 
+#[cfg(feature = "rust-crypto")]
+impl<P, C, H, CP> Default for PredicateVerifier<P, C, H, CP>
+where
+    P: Default,
+    C: Default,
+    H: Default,
+{
+    fn default() -> Self {
+        Self {
+            predicates: P::default(),
+            voting_power_calculator: C::default(),
+            commit_validator: ProdCommitValidator::default(),
+            hasher: H::default(),
+            _p: PhantomData::default(),
+        }
+    }
+}
+
+#[cfg(not(feature = "rust-crypto"))]
 impl<P, C, H, CP> PredicateVerifier<P, C, H, CP>
 where
     P: VerificationPredicates,
@@ -119,6 +154,31 @@ where
     }
 }
 
+#[cfg(feature = "rust-crypto")]
+impl<P, C, H, CP> PredicateVerifier<P, C, H, CP>
+where
+    P: VerificationPredicates,
+    C: VotingPowerCalculator,
+    H: Hasher,
+    CP: CryptoProvider,
+{
+    /// Constructor.
+    pub fn new(
+        predicates: P,
+        voting_power_calculator: C,
+        commit_validator: ProdCommitValidator,
+        hasher: H,
+    ) -> Self {
+        Self {
+            predicates,
+            voting_power_calculator,
+            hasher,
+            commit_validator,
+            _p: PhantomData::default(),
+        }
+    }
+}
+
 impl<P, C, H, CP> Verifier for PredicateVerifier<P, C, H, CP>
 where
     P: VerificationPredicates + VerificationPredicates<CryptoProvider = CP>,

tendermint/src/crypto.rs

@@ -15,6 +15,7 @@ pub trait CryptoProvider {
 /// A default implementation of the HostFunctionManager that uses the [`CryptoProvider`] trait
 use core::marker::PhantomData;
 
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct DefaultHostFunctionsManager;
 use k256::ecdsa::{SigningKey, VerifyingKey};