tweak(vrf): Optimize to_group by avoiding the recomputation of constants

Author: tizoc

vrf/src/message.rs

@@ -1,3 +1,5 @@
+use std::sync::OnceLock;
+
 use ark_ff::{One, SquareRootField, Zero};
 
 use ledger::{proofs::transaction::legacy_input::to_bits, ToInputs};
@@ -18,6 +20,26 @@ pub struct VrfMessage {
     delegator_index: u64,
 }
 
+struct CachedFields {
+    two: BaseField,
+    three: BaseField,
+    five: BaseField,
+    projection_point_z: BaseField,
+    // Add other fields here that might benefit from caching
+}
+
+static CACHED_FIELDS: OnceLock<CachedFields> = OnceLock::new();
+
+#[inline(always)]
+fn get_y(x: BaseField, five: BaseField) -> Option<BaseField> {
+    let mut res = x;
+    res *= &x; // x^2
+    res += BaseField::zero(); // x^2 + A x
+    res *= &x; // x^3 + A x
+    res += five; // x^3 + A x + B
+    res.sqrt()
+}
+
 impl VrfMessage {
     pub fn new(global_slot: u32, epoch_seed: EpochSeed, delegator_index: u64) -> Self {
         Self {
@@ -32,27 +54,38 @@ impl VrfMessage {
     }
 
     pub fn to_group(&self) -> VrfResult<CurvePoint> {
-        // helpers
-        let two = BaseField::one() + BaseField::one();
-        let three = two + BaseField::one();
-
-        // params, according to ocaml
-        let mut projection_point_z_bytes =
-            hex::decode("1AF731EC3CA2D77CC5D13EDC8C9A0A77978CB5F4FBFCC470B5983F5B6336DB69")?;
-        projection_point_z_bytes.reverse();
-        let projection_point_z = BaseField::from_bytes(&projection_point_z_bytes)?;
+        let cached = CACHED_FIELDS.get_or_init(|| {
+            let one = BaseField::one();
+            let two = one + one;
+            let three = two + one;
+            let five = three + two;
+
+            let projection_point_z_bytes =
+                hex::decode("1AF731EC3CA2D77CC5D13EDC8C9A0A77978CB5F4FBFCC470B5983F5B6336DB69")
+                    .expect("Failed to decode hex string");
+            let projection_point_z = BaseField::from_bytes(&projection_point_z_bytes)
+                .expect("Failed to convert bytes to BaseField");
+
+            CachedFields {
+                two,
+                three,
+                five,
+                projection_point_z,
+            }
+        });
+
         let projection_point_y = BaseField::one();
-        let conic_c = three;
+        let conic_c = cached.three;
         let u_over_2 = BaseField::one();
-        let u = two;
+        let u = cached.two;
 
         let t = self.hash();
 
         // field to conic
         let ct = conic_c * t;
-        let s =
-            two * ((ct * projection_point_y) + projection_point_z) / ((ct * t) + BaseField::one());
-        let conic_z = projection_point_z - s;
+        let s = cached.two * ((ct * projection_point_y) + cached.projection_point_z)
+            / ((ct * t) + BaseField::one());
+        let conic_z = cached.projection_point_z - s;
         let conic_y = projection_point_y - (s * t);
 
         // conic to s
@@ -64,22 +97,8 @@ impl VrfMessage {
         let x2 = -(u + v);
         let x3 = u + (y * y);
 
-        let get_y = |x: BaseField| -> Option<BaseField> {
-            let five = BaseField::one()
-                + BaseField::one()
-                + BaseField::one()
-                + BaseField::one()
-                + BaseField::one();
-            let mut res = x;
-            res *= &x; // x^2
-            res += BaseField::zero(); // x^2 + A x
-            res *= &x; // x^3 + A x
-            res += five; // x^3 + A x + B
-            res.sqrt()
-        };
-
         for x in [x1, x2, x3] {
-            if let Some(y) = get_y(x) {
+            if let Some(y) = get_y(x, cached.five) {
                 return Ok(CurvePoint::new(x, y, false));
             }
         }