Rust 1.80

Preserves the fn accessors within the Monero crates so that we can use statics
in some cfgs yet not all (in order to provide support for more low-memory
devices) with the exception of `H` (which truly should be cached).

networks/monero/primitives/Cargo.toml

@@ -6,7 +6,7 @@ license = "MIT"
 repository = "https://github.com/serai-dex/serai/tree/develop/networks/monero/primitives"
 authors = ["Luke Parker <lukeparker5132@gmail.com>"]
 edition = "2021"
-rust-version = "1.79"
+rust-version = "1.80"
 
 [package.metadata.docs.rs]
 all-features = true

networks/monero/primitives/src/lib.rs

@@ -5,7 +5,7 @@
 
 use std_shims::{io, vec::Vec};
 #[cfg(feature = "std")]
-use std_shims::sync::OnceLock;
+use std_shims::sync::LazyLock;
 
 use zeroize::{Zeroize, ZeroizeOnDrop};
 
@@ -28,15 +28,15 @@ mod tests;
 
 // On std, we cache some variables in statics.
 #[cfg(feature = "std")]
-static INV_EIGHT_CELL: OnceLock<Scalar> = OnceLock::new();
-/// The inverse of 8 over l.
+static INV_EIGHT_CELL: LazyLock<Scalar> = LazyLock::new(|| Scalar::from(8u8).invert());
+/// The inverse of 8 over l, the prime factor of the order of Ed25519.
 #[cfg(feature = "std")]
 #[allow(non_snake_case)]
 pub fn INV_EIGHT() -> Scalar {
-  *INV_EIGHT_CELL.get_or_init(|| Scalar::from(8u8).invert())
+  *INV_EIGHT_CELL
 }
 // In no-std environments, we prefer the reduced memory use and calculate it ad-hoc.
-/// The inverse of 8 over l.
+/// The inverse of 8 over l, the prime factor of the order of Ed25519.
 #[cfg(not(feature = "std"))]
 #[allow(non_snake_case)]
 pub fn INV_EIGHT() -> Scalar {
@@ -44,12 +44,13 @@ pub fn INV_EIGHT() -> Scalar {
 }
 
 #[cfg(feature = "std")]
-static G_PRECOMP_CELL: OnceLock<VartimeEdwardsPrecomputation> = OnceLock::new();
+static G_PRECOMP_CELL: LazyLock<VartimeEdwardsPrecomputation> =
+  LazyLock::new(|| VartimeEdwardsPrecomputation::new([ED25519_BASEPOINT_POINT]));
 /// A cached (if std) pre-computation of the Ed25519 generator, G.
 #[cfg(feature = "std")]
 #[allow(non_snake_case)]
 pub fn G_PRECOMP() -> &'static VartimeEdwardsPrecomputation {
-  G_PRECOMP_CELL.get_or_init(|| VartimeEdwardsPrecomputation::new([ED25519_BASEPOINT_POINT]))
+  &G_PRECOMP_CELL
 }
 /// A cached (if std) pre-computation of the Ed25519 generator, G.
 #[cfg(not(feature = "std"))]
@@ -105,7 +106,7 @@ impl Commitment {
 
   /// Calculate the Pedersen commitment, as a point, from this transparent structure.
   pub fn calculate(&self) -> EdwardsPoint {
-    EdwardsPoint::vartime_double_scalar_mul_basepoint(&Scalar::from(self.amount), &H(), &self.mask)
+    EdwardsPoint::vartime_double_scalar_mul_basepoint(&Scalar::from(self.amount), &H, &self.mask)
   }
 
   /// Write the Commitment.

networks/monero/primitives/src/unreduced_scalar.rs

@@ -1,6 +1,6 @@
 use core::cmp::Ordering;
 use std_shims::{
-  sync::OnceLock,
+  sync::LazyLock,
   io::{self, *},
 };
 
@@ -10,18 +10,14 @@ use curve25519_dalek::scalar::Scalar;
 
 use monero_io::*;
 
-static PRECOMPUTED_SCALARS_CELL: OnceLock<[Scalar; 8]> = OnceLock::new();
 // Precomputed scalars used to recover an incorrectly reduced scalar.
-#[allow(non_snake_case)]
-fn PRECOMPUTED_SCALARS() -> [Scalar; 8] {
-  *PRECOMPUTED_SCALARS_CELL.get_or_init(|| {
-    let mut precomputed_scalars = [Scalar::ONE; 8];
-    for (i, scalar) in precomputed_scalars.iter_mut().enumerate().skip(1) {
-      *scalar = Scalar::from(u8::try_from((i * 2) + 1).unwrap());
-    }
-    precomputed_scalars
-  })
-}
+static PRECOMPUTED_SCALARS: LazyLock<[Scalar; 8]> = LazyLock::new(|| {
+  let mut precomputed_scalars = [Scalar::ONE; 8];
+  for (i, scalar) in precomputed_scalars.iter_mut().enumerate().skip(1) {
+    *scalar = Scalar::from(u8::try_from((i * 2) + 1).unwrap());
+  }
+  precomputed_scalars
+});
 
 /// An unreduced scalar.
 ///
@@ -127,14 +123,12 @@ impl UnreducedScalar {
       return Scalar::from_bytes_mod_order(self.0);
     }
 
-    let precomputed_scalars = PRECOMPUTED_SCALARS();
-
     let mut recovered = Scalar::ZERO;
     for &numb in self.non_adjacent_form().iter().rev() {
       recovered += recovered;
       match numb.cmp(&0) {
-        Ordering::Greater => recovered += precomputed_scalars[usize::try_from(numb).unwrap() / 2],
-        Ordering::Less => recovered -= precomputed_scalars[usize::try_from(-numb).unwrap() / 2],
+        Ordering::Greater => recovered += PRECOMPUTED_SCALARS[usize::try_from(numb).unwrap() / 2],
+        Ordering::Less => recovered -= PRECOMPUTED_SCALARS[usize::try_from(-numb).unwrap() / 2],
         Ordering::Equal => (),
       }
     }