Shosha compatibility.

Cargo.toml

@@ -23,14 +23,15 @@ ark-crypto-primitives = {version="0.4.0", optional=true}
 curve25519-dalek = {version="4.0.0", optional=true}
 group = {version="0.13.0", optional=true}
 
+# anemoi = {git="https://github.com/mmaker/anemoi"}
+
 [features]
 default = []
 arkworks = ["dep:ark-ff", "dep:ark-ec", "dep:ark-serialize", "dep:ark-crypto-primitives"]
 dalek = ["dep:curve25519-dalek"]
 zkcrypto = ["dep:group"]
 
 [dev-dependencies]
-ark-bls12-381 = "0.4.0"
 ark-std = "0.4.0"
 sha2 = "0.10.7"
 blake2 = "0.10.6"

examples/bulletproof.rs

@@ -185,7 +185,9 @@ fn main() {
 
     // the test vectors
     let a = (0..size).map(|x| F::from(x as u32)).collect::<Vec<_>>();
-    let b = (0..size).map(|x| F::from(x as u32 + 42)).collect::<Vec<_>>();
+    let b = (0..size)
+        .map(|x| F::from(x as u32 + 42))
+        .collect::<Vec<_>>();
     let ab = inner_prod(&a, &b);
     // the generators to be used for respectively a, b, ip
     let g = (0..a.len())

scripts/useful_bits_modp.py

@@ -1,23 +1,19 @@
 """
-Use this program to find the number of bits that appear uniformly random
-in the uniform distribution mod p.
-
-While this function is trivial for byte-oriented hashes, for algebraic hashes, it requires proper implementation.
-Many implementations simply truncate the least-significant bits, but this approach
-results in a statistical deviation from uniform randomness. The number of useful bits, denoted as `n`,
 has a statistical distance from uniformly random given by:
 
 p is provided on stdin in any format that python can eval. For example,
 
 $ python3 scripts/useful_bits_modp.py <<< 0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaab
 """
 
+
 def useful_bits(p):
-    for n in range(p.bit_length()-1, 0, -1):
-        alpha = p % 2^n
-        if n+1 + p.bit_length() - alpha.bit_length() - (2^n-alpha).bit_length() >= 128:
-            return n
+    return max(
+        n for n in range(p.bit_length() - 1, 0, -1)
+        if n + 1 + p.bit_length() - (alpha := p % 2 ** n).bit_length() -
+        (2 ** n - alpha).bit_length() >= 128
+    )
 
 
 if __name__ == '__main__':
-   print(useful_bits(eval(input())))
+    print(useful_bits(eval(input())))