Revisit the pow plugin and make it shorter and working.

src/iopattern.rs

@@ -86,30 +86,45 @@ impl<H: DuplexHash<U>, U: Unit> IOPattern<H, U> {
 
     /// Create a new IOPattern with the domain separator.
     pub fn new(domsep: &str) -> Self {
-        assert!(!domsep.contains(SEP_BYTE), "Domain separator cannot contain the separator BYTE.");
+        assert!(
+            !domsep.contains(SEP_BYTE),
+            "Domain separator cannot contain the separator BYTE."
+        );
         Self::from_string(domsep.to_string())
     }
 
     /// Absorb `count` native elements.
     pub fn absorb(self, count: usize, label: &str) -> Self {
         assert!(count > 0, "Count must be positive.");
-        assert!(!label.contains(SEP_BYTE), "Label cannot contain the separator BYTE.");
-        assert!(match label.chars().next() {
-            Some(char) => !char.is_ascii_digit(),
-            None => true,
-        }, "Label cannot start with a digit.");
+        assert!(
+            !label.contains(SEP_BYTE),
+            "Label cannot contain the separator BYTE."
+        );
+        assert!(
+            match label.chars().next() {
+                Some(char) => !char.is_ascii_digit(),
+                None => true,
+            },
+            "Label cannot start with a digit."
+        );
 
         Self::from_string(self.io + SEP_BYTE + &format!("A{}", count) + label)
     }
 
     /// Squeeze `count` native elements.
     pub fn squeeze(self, count: usize, label: &str) -> Self {
         assert!(count > 0, "Count must be positive.");
-        assert!(!label.contains(SEP_BYTE), "Label cannot contain the separator BYTE.");
-        assert!(match label.chars().next() {
-            Some(char) => !char.is_ascii_digit(),
-            None => true,
-        }, "Label cannot start with a digit.");
+        assert!(
+            !label.contains(SEP_BYTE),
+            "Label cannot contain the separator BYTE."
+        );
+        assert!(
+            match label.chars().next() {
+                Some(char) => !char.is_ascii_digit(),
+                None => true,
+            },
+            "Label cannot start with a digit."
+        );
 
         Self::from_string(self.io + SEP_BYTE + &format!("S{}", count) + label)
     }

src/plugins/ark/common.rs

@@ -8,7 +8,7 @@ use rand::{CryptoRng, RngCore};
 use super::{FieldChallenges, FieldPublic, GroupPublic};
 use crate::plugins::bytes_uniform_modp;
 use crate::{
-    Merlin, ByteChallenges, BytePublic, DuplexHash, IOPatternError, Arthur, ProofError,
+    Arthur, ByteChallenges, BytePublic, DuplexHash, IOPatternError, Merlin, ProofError,
     ProofResult, Unit, UnitTranscript,
 };
 

src/plugins/ark/mod.rs

@@ -136,7 +136,7 @@ mod tests;
 pub mod anemoi;
 
 pub use crate::traits::*;
-pub use crate::{hash::Unit, Merlin, DuplexHash, IOPattern, Arthur, ProofError, ProofResult, Safe};
+pub use crate::{hash::Unit, Arthur, DuplexHash, IOPattern, Merlin, ProofError, ProofResult, Safe};
 
 super::traits::field_traits!(ark_ff::Field);
 super::traits::group_traits!(ark_ec::CurveGroup, Scalar: ark_ff::PrimeField);

src/plugins/ark/reader.rs

@@ -7,7 +7,7 @@ use ark_serialize::CanonicalDeserialize;
 
 use super::{FieldReader, GroupReader};
 use crate::traits::*;
-use crate::{DuplexHash, Arthur, ProofResult};
+use crate::{Arthur, DuplexHash, ProofResult};
 
 impl<'a, F, H> FieldReader<F> for Arthur<'a, H>
 where

src/plugins/ark/tests.rs

@@ -1,8 +1,8 @@
+#[cfg(feature = "ark-bls12-381")]
+use super::poseidon::PoseidonHash;
 use crate::{DefaultHash, DuplexHash, IOPattern, Unit, UnitTranscript};
 #[cfg(feature = "ark-bls12-381")]
 use ark_bls12_381::Fr;
-#[cfg(feature = "ark-bls12-381")]
-use super::poseidon::PoseidonHash;
 
 /// Test that the algebraic hashes do use the IV generated from the IO Pattern.
 fn check_iv_is_used<H: DuplexHash<F>, F: Unit + Copy + Default + Eq + core::fmt::Debug>() {

src/plugins/ark/writer.rs

@@ -4,7 +4,7 @@ use ark_serialize::CanonicalSerialize;
 use rand::{CryptoRng, RngCore};
 
 use super::{FieldPublic, FieldWriter, GroupPublic, GroupWriter};
-use crate::{Merlin, DuplexHash, ProofResult, UnitTranscript};
+use crate::{DuplexHash, Merlin, ProofResult, UnitTranscript};
 
 impl<F: PrimeField, H: DuplexHash, R: RngCore + CryptoRng> FieldWriter<F> for Merlin<H, u8, R> {
     fn add_scalars(&mut self, input: &[F]) -> ProofResult<()> {

src/plugins/group/reader.rs

@@ -1,5 +1,5 @@
 use super::FieldReader;
-use crate::{ByteReader, DuplexHash, Arthur, ProofError};
+use crate::{Arthur, ByteReader, DuplexHash, ProofError};
 use group::ff::PrimeField;
 
 impl<'a, F, H, const N: usize> FieldReader<F> for Arthur<'a, H>

src/plugins/group/writer.rs

@@ -2,7 +2,7 @@ use group::{ff::PrimeField, Group, GroupEncoding};
 use rand::{CryptoRng, RngCore};
 
 use super::{FieldPublic, FieldWriter, GroupPublic, GroupWriter};
-use crate::{Merlin, ByteWriter, DuplexHash, ProofResult};
+use crate::{ByteWriter, DuplexHash, Merlin, ProofResult};
 
 impl<F, H, R> FieldWriter<F> for Merlin<H, u8, R>
 where

src/plugins/mod.rs

@@ -1,6 +1,7 @@
 //!  Bindings for some popular libearies using zero-knowledge.
 
 /// Extension traits macros, for both arkworks and group.
+#[cfg(any(feature = "ark", feature = "group"))]
 mod traits;
 
 #[cfg(feature = "ark")]
@@ -12,15 +13,17 @@ pub mod ark;
 /// This plugin is experimental and has not yet been thoroughly tested.
 pub mod group;
 
-/// Experimental PoW support
-pub mod proof_of_work;
+/// Proof of work (PoW) challenges.
+pub mod pow;
 
 /// Bits needed in order to obtain a (pseudo-random) uniform distribution in F.
+#[allow(unused)]
 pub(super) const fn bytes_uniform_modp(modulus_bits: u32) -> usize {
     (modulus_bits as usize + 128) / 8
 }
 
 /// Bits needed in order to encode an element of F.
+#[allow(unused)]
 pub(super) const fn bytes_modp(modulus_bits: u32) -> usize {
     (modulus_bits as usize + 7) / 8
 }

src/tests.rs

@@ -3,7 +3,7 @@ use rand::RngCore;
 use crate::hash::keccak::Keccak;
 use crate::hash::legacy::DigestBridge;
 use crate::{
-    Merlin, ByteChallenges, BytePublic, ByteReader, ByteWriter, DuplexHash, IOPattern, Safe,
+    ByteChallenges, BytePublic, ByteReader, ByteWriter, DuplexHash, IOPattern, Merlin, Safe,
 };
 
 type Sha2 = DigestBridge<sha2::Sha256>;

src/traits.rs

@@ -12,7 +12,6 @@ pub trait UnitTranscript<U: Unit> {
     fn fill_challenge_units(&mut self, output: &mut [U]) -> Result<(), IOPatternError>;
 }
 
-
 /// Absorbing bytes from the sponge, without reading or writing them into the protocol transcript.
 ///
 /// This trait is trivial for byte-oriented sponges, but non-trivial for algebraic hashes.