Applied edits

Author: SyntheticBird45

helper/Cargo.toml

@@ -10,13 +10,13 @@ repository = "https://github.com/Cuprate/cuprate/tree/main/consensus"
 
 [features]
 # All features off by default.
-default   = ["std"]
+default   = []
 std       = []
 atomic    = ["dep:crossbeam"]
 asynch    = ["dep:futures", "dep:rayon"]
 cast      = []
 constants = []
-crypto    = ["dep:curve25519-dalek", "dep:monero-serai"]
+crypto    = ["dep:curve25519-dalek", "dep:monero-serai", "std"]
 fs        = ["dep:dirs"]
 num       = []
 map       = ["cast", "dep:monero-serai", "dep:cuprate-constants"]

helper/src/crypto.rs

@@ -9,7 +9,7 @@ use curve25519_dalek::{
 };
 use monero_serai::generators::H;
 
-/// This is the decomposed amount table containing the mandatory Pre-RCT amounts. It is use to pre-compute 
+/// This is the decomposed amount table containing the mandatory Pre-RCT amounts. It is used to pre-compute 
 /// zero commitments at runtime.
 /// 
 /// Defined at:
@@ -38,13 +38,14 @@ const ZERO_COMMITMENT_DECOMPOSED_AMOUNT: [u64; 172] = [
     10000000000000000000
 ];
 
-/// Runtime initialized H generator.
+/// Runtime initialized [`H`] generator.
 static H_PRECOMP: LazyLock<VartimeEdwardsPrecomputation> =
     LazyLock::new(|| VartimeEdwardsPrecomputation::new([*H, ED25519_BASEPOINT_POINT]));
 
 /// Runtime initialized zero commitment lookup table
 ///
-/// ASSUMPTION: This function assume that the [`ZERO_COMMITMENT_DECOMPOSED_AMOUNT`]
+/// # Invariant
+/// This function assumes that the [`ZERO_COMMITMENT_DECOMPOSED_AMOUNT`]
 /// table is sorted.
 pub static ZERO_COMMITMENT_LOOKUP_TABLE: LazyLock<[(u64, EdwardsPoint); 172]> =
     LazyLock::new(|| {
@@ -60,34 +61,41 @@ pub static ZERO_COMMITMENT_LOOKUP_TABLE: LazyLock<[(u64, EdwardsPoint); 172]> =
         lookup_table
     });
 
-/// This function compute the zero commitment given a specific amount.
+/// This function computes the zero commitment given a specific amount.
 ///
 /// It will first attempt to lookup into the table of known Pre-RCT value.
 /// Compute it otherwise.
+#[expect(clippy::cast_possible_truncation)]
 pub fn compute_zero_commitments(amount: u64) -> EdwardsPoint {
-    // OPTIMIZATION: We first make an arithmetic check that the value lies between valid pre-computed amounts. This permit to avoid the lookup cost if possible
-    if amount > 10 && amount % 10 != 0 {
-        return H_PRECOMP.vartime_multiscalar_mul([Scalar::from(amount), Scalar::from(1_u8)]);
+    
+    if amount == 0 {
+        return H_PRECOMP.vartime_multiscalar_mul([Scalar::from(amount), Scalar::from(1_u8)])
     }
+    
+    // OPTIMIZATION: Unlike monerod which execute a linear search across its lookup 
+    // table (O(n)). Cuprate is making use of an arithmetic based constant time
+    // version (O(1)). It has been benchmarked in both hit and miss scenarios against
+    // a binary search lookup (O(log2(n))). To understand the following algorithm it 
+    // is important to observe the pattern that follows the values of 
+    // [`ZERO_COMMITMENT_DECOMPOSED_AMOUNT`].
+    
+    // First obtain the logarithm base 10 of the amount. and extend it back to obtain 
+    // the amount without its most significant digit.
+    let log = amount.checked_ilog10().unwrap();
+    let div = 10_u64.pow(log);
 
-    // Binary search in lookup table (O(log2(n)) instead of O(n))
-    let (mut start, mut end): (usize, usize) = (0, (ZERO_COMMITMENT_LOOKUP_TABLE.len() - 1));
-    while start <= end {
-        let mid = (start + end) / 2;
-        let lookup = ZERO_COMMITMENT_LOOKUP_TABLE[mid].0;
-        match amount {
-            a if a == lookup => {
-                return ZERO_COMMITMENT_LOOKUP_TABLE[mid].1;
-            }
-            a if a < lookup => {
-                end = mid - 1;
-            }
-            _ => {
-                start = mid + 1;
-            }
-        }
-    }
+    // Extract the most significant digit.
+    let most_significant_digit = amount / div;
 
-    // Compute the zero commitment if not found.
-    H_PRECOMP.vartime_multiscalar_mul([Scalar::from(amount), Scalar::from(1_u8)])
+    // If the *rounded* version is different than the exact amount. Then 
+    // there aren't only trailing zeroes behind the most significant digit.
+    // The amount is not part of the table and can calculated apart.
+    if most_significant_digit * div != amount {
+        return H_PRECOMP.vartime_multiscalar_mul([Scalar::from(amount), Scalar::ONE]);
+    }
+    
+    // Calculating the index back by progressing within the powers of 10.
+    let index = (most_significant_digit + u64::from(log) * 10 - (u64::from(log) + 1)) as usize;
+    
+    ZERO_COMMITMENT_LOOKUP_TABLE[index].1
 }

helper/src/lib.rs

@@ -31,7 +31,7 @@ pub mod time;
 #[cfg(feature = "tx")]
 pub mod tx;
 
-#[cfg(all(feature = "crypto", feature = "std"))]
+#[cfg(feature = "crypto")]
 pub mod crypto;
 //---------------------------------------------------------------------------------------------------- Private Usage