diff --git a/.github/workflows/readme.yml b/.github/workflows/readme.yml
index 1da05a3..1b2504d 100644
--- a/.github/workflows/readme.yml
+++ b/.github/workflows/readme.yml
@@ -19,6 +19,8 @@ jobs:
         crate: cargo-rdme
     - uses: webfactory/ssh-agent@v0.7.0
       with:
-        ssh-private-key: ${{ secrets.STARK_CURVE_KEY }}
+        ssh-private-key: |
+          ${{ secrets.STARK_CURVE_KEY }}
+          ${{ secrets.UDIGEST_KEY }}
     - name: Check that readme matches lib.rs
       run: cargo rdme -w generic-ec -r README.md --check
diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
index c07ba1c..a403dbb 100644
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -15,7 +15,9 @@ jobs:
     - uses: actions/checkout@v3
     - uses: webfactory/ssh-agent@v0.7.0
       with:
-        ssh-private-key: ${{ secrets.STARK_CURVE_KEY }}
+        ssh-private-key: |
+          ${{ secrets.STARK_CURVE_KEY }}
+          ${{ secrets.UDIGEST_KEY }}
     - uses: Swatinem/rust-cache@v2
       with:
         cache-on-failure: "true"
@@ -41,7 +43,9 @@ jobs:
     - uses: actions/checkout@v3
     - uses: webfactory/ssh-agent@v0.7.0
       with:
-        ssh-private-key: ${{ secrets.STARK_CURVE_KEY }}
+        ssh-private-key: |
+          ${{ secrets.STARK_CURVE_KEY }}
+          ${{ secrets.UDIGEST_KEY }}
     - uses: Swatinem/rust-cache@v2
       with:
         cache-on-failure: "true"
diff --git a/generic-ec-curves/src/rust_crypto/mod.rs b/generic-ec-curves/src/rust_crypto/mod.rs
index 040e262..39302ea 100644
--- a/generic-ec-curves/src/rust_crypto/mod.rs
+++ b/generic-ec-curves/src/rust_crypto/mod.rs
@@ -99,8 +99,8 @@ impl<C, X> PartialEq for RustCryptoCurve<C, X> {
 impl<C, X> Eq for RustCryptoCurve<C, X> {}
 
 impl<C, X> PartialOrd for RustCryptoCurve<C, X> {
-    fn partial_cmp(&self, _other: &Self) -> Option<core::cmp::Ordering> {
-        Some(core::cmp::Ordering::Equal)
+    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
+        Some(self.cmp(other))
     }
 }
 
diff --git a/generic-ec-zkp/Cargo.toml b/generic-ec-zkp/Cargo.toml
index 41a6a11..d9bc683 100644
--- a/generic-ec-zkp/Cargo.toml
+++ b/generic-ec-zkp/Cargo.toml
@@ -7,9 +7,9 @@ edition = "2021"
 
 [dependencies]
 generic-ec = { path = "../generic-ec", default-features = false }
+udigest = { git = "https://github.com/dfns-labs/udigest", branch = "m", features = ["derive"], optional = true }
 
 subtle = "2.4"
-digest = "0.10"
 rand_core = "0.6"
 
 serde = { version = "1", features = ["derive"], optional = true }
@@ -29,5 +29,6 @@ generic-ec = { path = "../generic-ec", default-features = false, features = ["al
 [features]
 default = ["std"]
 std = ["alloc"]
-alloc = []
+alloc = ["udigest/alloc"]
 serde = ["dep:serde", "generic-ec/serde", "generic-array/serde"]
+udigest = ["dep:udigest", "generic-ec/udigest"]
diff --git a/generic-ec-zkp/src/hash_commitment.rs b/generic-ec-zkp/src/hash_commitment.rs
deleted file mode 100644
index a21a05e..0000000
--- a/generic-ec-zkp/src/hash_commitment.rs
+++ /dev/null
@@ -1,288 +0,0 @@
-//! Hash commitment
-//!
-//! Hash commitment is a procedure that allows player $\P$ to commit some value (scalar, point, byte string, etc.),
-//! and reveal it later on. Player $\V$ can verify that commitment matches revealed value.
-//!
-//! ## Example
-//!
-//! 1. $\P$ commits some data (point, scalars, slices, whatever that can be represented as bytes):
-//!    ```rust
-//!    # use generic_ec::{Point, Scalar, Curve};
-//!    # use generic_ec_zkp::hash_commitment::HashCommit;
-//!    # use sha2::Sha256; use rand::rngs::OsRng;
-//!    #
-//!    # fn doc_fn<E: Curve>() {
-//!    let point: Point<E> = some_point();
-//!    let scalars: &[Scalar<E>] = some_scalars();
-//!    let arbitrary_data: &[&[u8]] = some_arbitrary_data();
-//!
-//!    let (commit, decommit) = HashCommit::<Sha256>::builder()
-//!        .mix(point)
-//!        .mix_many(scalars)
-//!        .mix_many_bytes(arbitrary_data)
-//!        .commit(&mut OsRng);
-//!    # }
-//!    # fn some_point<E: Curve>() -> Point<E> { unimplemented!() }
-//!    # fn some_scalars<T>() -> T { unimplemented!() }
-//!    # fn some_arbitrary_data<T>() -> T { unimplemented!() }
-//!    ```
-//! 2. $\P$ sends `commit` to $\V$
-//! 3. At some point, $\P$ chooses to reveal committed data. It sends data + `decommit` to $\V$.
-//!
-//!    $\V$ verifies that revealed data matches `commit`:
-//!
-//!    ```rust
-//!    # use generic_ec::{Point, Scalar, Curve};
-//!    # use generic_ec_zkp::hash_commitment::{HashCommit, DecommitNonce, MismatchedRevealedData};
-//!    # use sha2::Sha256;
-//!    #
-//!    # fn doc_fn<E: Curve>() -> Result<(), MismatchedRevealedData> {
-//!    # let commit: HashCommit<Sha256> = unimplemented!();
-//!    # let (point, scalars, arbitrary_data): (Point<E>, &[Scalar<E>], &[&[u8]]) = unimplemented!();
-//!    # let decommit: DecommitNonce<Sha256> = unimplemented!();
-//!    HashCommit::<Sha256>::builder()
-//!        .mix(point)
-//!        .mix_many(scalars)
-//!        .mix_many_bytes(arbitrary_data)
-//!        .verify(&commit, &decommit)?;
-//!    # }
-//!    ```
-//!
-//! ## Algorithm
-//! Underlying algorithm of hashing input data is based on merkle trees.
-
-use digest::{generic_array::GenericArray, Digest, Output};
-use rand_core::RngCore;
-use subtle::ConstantTimeEq;
-
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
-
-use generic_ec::{Curve, Point, Scalar};
-
-/// Builder for commitment/verification
-pub struct Builder<D: Digest>(D);
-
-impl<D: Digest> Builder<D> {
-    /// Creates an instance of [`Builder`]
-    pub fn new() -> Self {
-        // Initialize hash with context separation string
-        Self(D::new_with_prefix(b"GENERIC_EC_HASH_COMMITMENT"))
-    }
-
-    /// Mixes value serialized to bytes into commitment
-    ///
-    /// You can use this method with [`Point<E>`](Point) or [`Scalar<E>`](Scalar). Also you can
-    /// implement [`EncodesToBytes`] for your own types.
-    ///
-    /// ```rust
-    /// use generic_ec::{Point, Scalar};
-    /// use generic_ec_zkp::hash_commitment::HashCommit;
-    /// # use sha2::Sha256;
-    /// # use rand::rngs::OsRng;
-    ///
-    /// # use generic_ec::Curve;
-    /// # fn doc_fn<E: Curve>() {
-    /// let point: Point<E> = some_point();
-    /// let scalar: Scalar<E> = some_scalar();
-    ///
-    /// let (commit, decommit) = HashCommit::<Sha256>::builder()
-    ///     .mix(point)
-    ///     .mix(scalar)
-    ///     .commit(&mut OsRng);
-    /// # }
-    /// # fn some_point<E: Curve>() -> Point<E> { unimplemented!() }
-    /// # fn some_scalar<E: Curve>() -> Scalar<E> { unimplemented!() }
-    /// ```
-    pub fn mix<T>(self, encodable: T) -> Self
-    where
-        T: EncodesToBytes,
-    {
-        self.mix_bytes(encodable.to_bytes())
-    }
-
-    /// Mixes values serialized to bytes into commitment
-    ///
-    /// ```rust
-    /// use generic_ec::Point;
-    /// use generic_ec_zkp::hash_commitment::HashCommit;
-    /// # use sha2::Sha256;
-    /// # use rand::rngs::OsRng;
-    ///
-    /// # use generic_ec::Curve;
-    /// # fn doc_fn<E: Curve>() {
-    /// let points: Vec<Point<E>> = some_points();
-    ///
-    /// let (commit, decommit) = HashCommit::<Sha256>::builder()
-    ///     .mix_many(&points)
-    ///     .commit(&mut OsRng);
-    /// # }
-    /// # fn some_points<E: Curve>() -> Vec<Point<E>> { unimplemented!() }
-    /// ```
-    pub fn mix_many(self, encodables: impl IntoIterator<Item = impl EncodesToBytes>) -> Self {
-        self.mix_many_bytes(encodables.into_iter().map(|i| i.to_bytes()))
-    }
-
-    /// Mixes bytes into commitment
-    ///
-    /// ```rust
-    /// use generic_ec_zkp::hash_commitment::HashCommit;
-    /// # use sha2::Sha256;
-    /// # use rand::rngs::OsRng;
-    ///
-    /// # use generic_ec::Curve;
-    /// # fn doc_fn<E: Curve>() {
-    /// let (commit, decommit) = HashCommit::<Sha256>::builder()
-    ///     .mix_bytes(b"some message")
-    ///     .commit(&mut OsRng);
-    /// # }
-    /// ```
-    pub fn mix_bytes(self, data: impl AsRef<[u8]>) -> Self {
-        Self(self.0.chain_update(digest_leaf::<D>(data)))
-    }
-
-    /// Mixes list of byte strings into commitment
-    ///
-    /// ```rust
-    /// use generic_ec_zkp::hash_commitment::HashCommit;
-    /// # use sha2::Sha256;
-    /// # use rand::rngs::OsRng;
-    ///
-    /// # use generic_ec::Curve;
-    /// # fn doc_fn<E: Curve>() {
-    /// let (commit, decommit) = HashCommit::<Sha256>::builder()
-    ///     .mix_many_bytes(&[b"some message".as_slice(), b"another message"])
-    ///     .commit(&mut OsRng);
-    /// # }
-    /// ```
-    pub fn mix_many_bytes(self, list: impl IntoIterator<Item = impl AsRef<[u8]>>) -> Self {
-        let hash = list
-            .into_iter()
-            .fold(digest_subtree::<D>(), |d, i| {
-                d.chain_update(digest_leaf::<D>(i))
-            })
-            .finalize();
-        Self(self.0.chain_update(hash))
-    }
-
-    /// Performs commitment
-    ///
-    /// Decommitment nonce is generated from provided randomness source
-    pub fn commit<R: RngCore>(self, rng: &mut R) -> (HashCommit<D>, DecommitNonce<D>) {
-        let mut nonce = DecommitNonce::<D>::default();
-        rng.fill_bytes(&mut nonce.nonce);
-        (self.commit_with_fixed_nonce(&nonce), nonce)
-    }
-
-    /// Performs commitment with specified decommitment nonce
-    pub fn commit_with_fixed_nonce(mut self, nonce: &DecommitNonce<D>) -> HashCommit<D> {
-        self = self.mix_bytes(&nonce.nonce);
-        let resulting_hash = self.0.finalize();
-        HashCommit(resulting_hash)
-    }
-
-    /// Verifies that provided data matches commitment and decommitment
-    pub fn verify(
-        self,
-        commit: &HashCommit<D>,
-        nonce: &DecommitNonce<D>,
-    ) -> Result<(), MismatchedRevealedData> {
-        let should_be = self.commit_with_fixed_nonce(nonce);
-        if commit.0.ct_eq(&should_be.0).into() {
-            Ok(())
-        } else {
-            Err(MismatchedRevealedData)
-        }
-    }
-}
-
-impl<D: Digest> Default for Builder<D> {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-/// Committed value
-#[derive(Clone)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(bound = ""))]
-pub struct HashCommit<D: Digest>(pub Output<D>);
-
-impl<D: Digest> HashCommit<D> {
-    pub fn builder() -> Builder<D> {
-        Builder::new()
-    }
-}
-
-/// Random nonce that was used to "blind" commitment
-#[derive(Clone)]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(bound = ""))]
-pub struct DecommitNonce<D: Digest> {
-    pub nonce: GenericArray<u8, D::OutputSize>,
-}
-
-impl<D: Digest> Default for DecommitNonce<D> {
-    fn default() -> Self {
-        Self {
-            nonce: Default::default(),
-        }
-    }
-}
-
-fn digest_leaf<D: Digest>(bytes: impl AsRef<[u8]>) -> digest::Output<D> {
-    D::new_with_prefix([0]).chain_update(bytes).finalize()
-}
-
-fn digest_subtree<D: Digest>() -> D {
-    D::new_with_prefix([1])
-}
-
-/// Infallibly encodable to bytes
-///
-/// Used in [`hash_commitment::Builder`](Builder) methods [`mix`](Builder::mix) and [`mix_many`](Builder::mix_many) to convert given value to bytes.
-pub trait EncodesToBytes {
-    /// Value byte representation
-    type Bytes: AsRef<[u8]>;
-    /// Encodes value to bytes
-    fn to_bytes(&self) -> Self::Bytes;
-}
-
-impl<T: EncodesToBytes> EncodesToBytes for &T {
-    type Bytes = T::Bytes;
-    fn to_bytes(&self) -> Self::Bytes {
-        <T as EncodesToBytes>::to_bytes(*self)
-    }
-}
-
-impl<E: Curve> EncodesToBytes for Point<E> {
-    type Bytes = generic_ec::EncodedPoint<E>;
-    fn to_bytes(&self) -> Self::Bytes {
-        self.to_bytes(true)
-    }
-}
-
-impl<E: Curve> EncodesToBytes for Scalar<E> {
-    type Bytes = generic_ec::EncodedScalar<E>;
-    fn to_bytes(&self) -> Self::Bytes {
-        self.to_be_bytes()
-    }
-}
-
-impl EncodesToBytes for u16 {
-    type Bytes = [u8; 2];
-    fn to_bytes(&self) -> Self::Bytes {
-        self.to_be_bytes()
-    }
-}
-
-/// Error indicating that revealed data doesn't match commitment
-#[derive(Debug, Clone, Copy)]
-pub struct MismatchedRevealedData;
-
-impl core::fmt::Display for MismatchedRevealedData {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        f.write_str("revealed data doesn't match commitment")
-    }
-}
-
-#[cfg(feature = "std")]
-impl std::error::Error for MismatchedRevealedData {}
diff --git a/generic-ec-zkp/src/lib.rs b/generic-ec-zkp/src/lib.rs
index 443543d..0456b63 100644
--- a/generic-ec-zkp/src/lib.rs
+++ b/generic-ec-zkp/src/lib.rs
@@ -9,6 +9,5 @@ extern crate alloc;
 // We don't want this dependency to trigger unused dep lint
 use generic_array as _;
 
-pub mod hash_commitment;
 pub mod polynomial;
 pub mod schnorr_pok;
diff --git a/generic-ec-zkp/src/polynomial.rs b/generic-ec-zkp/src/polynomial.rs
index ef879c7..4d508e7 100644
--- a/generic-ec-zkp/src/polynomial.rs
+++ b/generic-ec-zkp/src/polynomial.rs
@@ -18,6 +18,7 @@ mod requires_alloc {
     /// Polynomial is generic over type of coefficients `C`, it can be `Scalar<E>`, `NonZero<Scalar<E>>`, `SecretScalar<E>`, `Point<E>`,
     /// or any other type that implements necessary traits.
     #[derive(Debug, Clone)]
+    #[cfg_attr(feature = "udigest", derive(udigest::Digestable))]
     pub struct Polynomial<C> {
         /// `coefs[i]` is coefficient of `x^i` term
         ///
diff --git a/generic-ec-zkp/src/schnorr_pok.rs b/generic-ec-zkp/src/schnorr_pok.rs
index b40bf3c..e2f1a54 100644
--- a/generic-ec-zkp/src/schnorr_pok.rs
+++ b/generic-ec-zkp/src/schnorr_pok.rs
@@ -89,6 +89,7 @@ use serde::{Deserialize, Serialize};
 /// Committed prover ephemeral secret
 #[derive(Clone)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(bound = ""))]
+#[cfg_attr(feature = "udigest", derive(udigest::Digestable), udigest(bound = ""))]
 pub struct Commit<E: Curve>(pub Point<E>);
 
 /// Prover ephemeral secret
@@ -99,6 +100,7 @@ pub struct ProverSecret<E: Curve> {
 /// Challenge generated by verifier
 #[derive(Clone)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(bound = ""))]
+#[cfg_attr(feature = "udigest", derive(udigest::Digestable), udigest(bound = ""))]
 pub struct Challenge<E: Curve> {
     pub nonce: Scalar<E>,
 }
@@ -115,6 +117,7 @@ impl<E: Curve> Challenge<E> {
 /// The proof that can convince $\V$ that $\P$ knows secret $x$
 #[derive(Clone)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(bound = ""))]
+#[cfg_attr(feature = "udigest", derive(udigest::Digestable), udigest(bound = ""))]
 pub struct Proof<E: Curve>(pub Scalar<E>);
 
 impl<E: Curve> Proof<E> {
diff --git a/generic-ec/Cargo.toml b/generic-ec/Cargo.toml
index 5bb50b8..8493359 100644
--- a/generic-ec/Cargo.toml
+++ b/generic-ec/Cargo.toml
@@ -13,6 +13,7 @@ categories = []
 [dependencies]
 generic-ec-core = { path = "../generic-ec-core" }
 generic-ec-curves = { path = "../generic-ec-curves", optional = true }
+udigest = { git = "https://github.com/dfns-labs/udigest", branch = "m", features = ["derive"], optional = true }
 
 subtle = { version = "2.4", default-features = false }
 rand_core = { version = "0.6", default-features = false }
@@ -37,6 +38,7 @@ default = ["std", "serde"]
 std = ["alloc"]
 alloc = ["hex/alloc"]
 serde = ["dep:serde", "generic-ec-core/serde", "hex", "serde_with"]
+udigest = ["dep:udigest"]
 
 curves = ["generic-ec-curves"]
 curve-secp256k1 = ["curves", "generic-ec-curves/secp256k1"]
diff --git a/generic-ec/src/coords.rs b/generic-ec/src/coords.rs
index c3c9c98..0ae9190 100644
--- a/generic-ec/src/coords.rs
+++ b/generic-ec/src/coords.rs
@@ -136,7 +136,7 @@ impl<E: Curve> Eq for Coordinate<E> {}
 
 impl<E: Curve> PartialOrd for Coordinate<E> {
     fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
-        self.as_be_bytes().partial_cmp(other.as_be_bytes())
+        Some(self.cmp(other))
     }
 }
 
diff --git a/generic-ec/src/non_zero/definition.rs b/generic-ec/src/non_zero/definition.rs
index bde43d1..64ef90e 100644
--- a/generic-ec/src/non_zero/definition.rs
+++ b/generic-ec/src/non_zero/definition.rs
@@ -13,6 +13,7 @@ use zeroize::Zeroize;
     )),
     serde(into = "T", try_from = "T")
 )]
+#[cfg_attr(feature = "udigest", derive(udigest::Digestable))]
 pub struct NonZero<T>(T);
 
 impl<T> NonZero<T> {
diff --git a/generic-ec/src/point/mod.rs b/generic-ec/src/point/mod.rs
index d44e3fb..643e164 100644
--- a/generic-ec/src/point/mod.rs
+++ b/generic-ec/src/point/mod.rs
@@ -173,9 +173,7 @@ impl<E: Curve> Hash for Point<E> {
 
 impl<E: Curve> PartialOrd for Point<E> {
     fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
-        self.to_bytes(true)
-            .as_bytes()
-            .partial_cmp(other.to_bytes(true).as_bytes())
+        Some(self.cmp(other))
     }
 }
 
@@ -202,3 +200,16 @@ impl<E: Curve> crate::traits::Zero for Point<E> {
         x.ct_eq(&Self::zero())
     }
 }
+
+#[cfg(feature = "udigest")]
+impl<E: Curve> udigest::Digestable for Point<E> {
+    fn unambiguously_encode<B>(&self, encoder: udigest::encoding::EncodeValue<B>)
+    where
+        B: udigest::Buffer,
+    {
+        let mut s = encoder.encode_struct();
+        s.add_field("curve").encode_leaf_value(E::CURVE_NAME);
+        s.add_field("point").encode_leaf_value(self.to_bytes(true));
+        s.finish();
+    }
+}
diff --git a/generic-ec/src/scalar.rs b/generic-ec/src/scalar.rs
index afeecc3..4f32a5a 100644
--- a/generic-ec/src/scalar.rs
+++ b/generic-ec/src/scalar.rs
@@ -342,9 +342,7 @@ impl<E: Curve> Hash for Scalar<E> {
 
 impl<E: Curve> PartialOrd for Scalar<E> {
     fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
-        self.to_be_bytes()
-            .as_bytes()
-            .partial_cmp(other.to_be_bytes().as_bytes())
+        Some(self.cmp(other))
     }
 }
 
@@ -355,3 +353,16 @@ impl<E: Curve> Ord for Scalar<E> {
             .cmp(other.to_be_bytes().as_bytes())
     }
 }
+
+#[cfg(feature = "udigest")]
+impl<E: Curve> udigest::Digestable for Scalar<E> {
+    fn unambiguously_encode<B>(&self, encoder: udigest::encoding::EncodeValue<B>)
+    where
+        B: udigest::Buffer,
+    {
+        let mut s = encoder.encode_struct();
+        s.add_field("curve").encode_leaf_value(E::CURVE_NAME);
+        s.add_field("scalar").encode_leaf_value(self.to_be_bytes());
+        s.finish();
+    }
+}