1  // Copyright (c) 2025-2026 ACDC Network
  2  // This file is part of the alphavm library.
  3  //
  4  // Alpha Chain | Delta Chain Protocol
  5  // International Monetary Graphite.
  6  //
  7  // Derived from Aleo (https://aleo.org) and ProvableHQ (https://provable.com).
  8  // They built world-class ZK infrastructure. We installed the EASY button.
  9  // Their cryptography: elegant. Our modifications: bureaucracy-compatible.
 10  // Original brilliance: theirs. Robert's Rules: ours. Bugs: definitely ours.
 11  //
 12  // Original Aleo/ProvableHQ code subject to Apache 2.0 https://www.apache.org/licenses/LICENSE-2.0
 13  // All modifications and new work: CC0 1.0 Universal Public Domain Dedication.
 14  // No rights reserved. No permission required. No warranty. No refunds.
 15  //
 16  // https://creativecommons.org/publicdomain/zero/1.0/
 17  // SPDX-License-Identifier: CC0-1.0
 18  
 19  use alphavm_curves::traits::ProjectiveCurve;
 20  use alphavm_fields::{FieldParameters, PrimeField};
 21  use alphavm_utilities::{cfg_into_iter, cfg_iter, cfg_iter_mut, ToBits};
 22  
 23  #[cfg(not(feature = "serial"))]
 24  use rayon::prelude::*;
 25  
 26  pub struct FixedBase;
 27  
 28  impl FixedBase {
 29      pub fn get_mul_window_size(num_scalars: usize) -> usize {
 30          match num_scalars < 32 {
 31              true => 3,
 32              false => super::ln_without_floats(num_scalars),
 33          }
 34      }
 35  
 36      pub fn get_window_table<T: ProjectiveCurve>(scalar_size: usize, window: usize, g: T) -> Vec<Vec<T>> {
 37          let in_window = 1 << window;
 38          let outerc = scalar_size.div_ceil(window);
 39          let last_in_window = 1 << (scalar_size - (outerc - 1) * window);
 40  
 41          let mut multiples_of_g = vec![vec![T::zero(); in_window]; outerc];
 42  
 43          let mut g_outer = g;
 44          let mut g_outers = Vec::with_capacity(outerc);
 45          for _ in 0..outerc {
 46              g_outers.push(g_outer);
 47              for _ in 0..window {
 48                  g_outer.double_in_place();
 49              }
 50          }
 51  
 52          cfg_iter_mut!(multiples_of_g).enumerate().take(outerc).zip(g_outers).for_each(
 53              |((outer, multiples_of_g), g_outer)| {
 54                  let cur_in_window = if outer == outerc - 1 { last_in_window } else { in_window };
 55  
 56                  let mut g_inner = T::zero();
 57                  for inner in multiples_of_g.iter_mut().take(cur_in_window) {
 58                      *inner = g_inner;
 59                      g_inner += &g_outer;
 60                  }
 61              },
 62          );
 63          multiples_of_g
 64      }
 65  
 66      pub fn windowed_mul<T: ProjectiveCurve>(
 67          outerc: usize,
 68          window: usize,
 69          multiples_of_g: &[Vec<T>],
 70          scalar: &T::ScalarField,
 71      ) -> T {
 72          let scalar_val = scalar.to_bigint().to_bits_le();
 73  
 74          cfg_into_iter!(0..outerc)
 75              .map(|outer| {
 76                  let mut inner = 0usize;
 77                  for i in 0..window {
 78                      if outer * window + i < (<T::ScalarField as PrimeField>::Parameters::MODULUS_BITS as usize)
 79                          && scalar_val[outer * window + i]
 80                      {
 81                          inner |= 1 << i;
 82                      }
 83                  }
 84                  multiples_of_g[outer][inner]
 85              })
 86              .sum::<T>()
 87              + multiples_of_g[0][0]
 88      }
 89  
 90      pub fn msm<T: ProjectiveCurve>(
 91          scalar_size: usize,
 92          window: usize,
 93          table: &[Vec<T>],
 94          v: &[T::ScalarField],
 95      ) -> Vec<T> {
 96          let outerc = scalar_size.div_ceil(window);
 97          assert!(outerc <= table.len());
 98  
 99          cfg_iter!(v).map(|e| Self::windowed_mul::<T>(outerc, window, table, e)).collect::<Vec<_>>()
100      }
101  }