From 7700b83f35557bc0ba8a488ff10ec2f2d2dc0390 Mon Sep 17 00:00:00 2001 From: jacobkaufmann Date: Tue, 6 Feb 2024 13:24:12 -0700 Subject: [PATCH] refactor: remove BLS scalar type --- src/blob.rs | 6 +-- src/bls.rs | 108 +++++++++++------------------------------------ src/kzg/setup.rs | 2 +- 3 files changed, 28 insertions(+), 88 deletions(-) diff --git a/src/blob.rs b/src/blob.rs index 04cf4ea..8dd42cd 100644 --- a/src/blob.rs +++ b/src/blob.rs @@ -1,5 +1,5 @@ use crate::{ - bls::{FiniteFieldError, Fr, Scalar, P1}, + bls::{FiniteFieldError, Fr, P1}, kzg::{Commitment, Polynomial, Proof, Setup}, math::BitReversalPermutation, }; @@ -67,7 +67,7 @@ impl Blob { } pub(crate) fn challenge(&self, commitment: &Commitment) -> Fr { - const DOMAIN: &'static [u8; 16] = b"FSBLOBVERIFY_V1_"; + const DOMAIN: &[u8; 16] = b"FSBLOBVERIFY_V1_"; let degree = (N as u128).to_be_bytes(); let comm = commitment.0.serialize(); @@ -76,7 +76,7 @@ impl Blob { data.extend_from_slice(DOMAIN); data.extend_from_slice(°ree); for element in self.elements.iter() { - let bytes = Scalar::from(element).to_be_bytes(); + let bytes = element.to_be_bytes(); data.extend_from_slice(&bytes); } data.extend_from_slice(&comm); diff --git a/src/bls.rs b/src/bls.rs index 2490f94..d444157 100644 --- a/src/bls.rs +++ b/src/bls.rs @@ -3,7 +3,6 @@ use std::{ ops::{Add, Div, Mul, Neg, Shl, ShlAssign, Shr, ShrAssign, Sub}, }; -use alloy_primitives::U256; use blst::{ blst_bendian_from_scalar, blst_final_exp, blst_fp, blst_fp12, blst_fp12_is_one, blst_fp12_mul, blst_fr, blst_fr_add, blst_fr_cneg, blst_fr_eucl_inverse, blst_fr_from_scalar, @@ -12,8 +11,8 @@ use blst::{ blst_p1_compress, blst_p1_deserialize, blst_p1_from_affine, blst_p1_mult, blst_p1_to_affine, blst_p2, blst_p2_add, blst_p2_affine, blst_p2_affine_in_g2, blst_p2_deserialize, blst_p2_from_affine, blst_p2_mult, blst_p2_to_affine, blst_scalar, blst_scalar_fr_check, - blst_scalar_from_bendian, blst_scalar_from_fr, blst_scalar_from_uint64, blst_sha256, - blst_uint64_from_fr, BLS12_381_G2, BLS12_381_NEG_G1, BLS12_381_NEG_G2, BLST_ERROR, + blst_scalar_from_bendian, blst_scalar_from_fr, blst_sha256, blst_uint64_from_fr, BLS12_381_G2, + BLS12_381_NEG_G1, BLS12_381_NEG_G2, BLST_ERROR, }; #[derive(Clone, Copy, Debug)] @@ -47,69 +46,6 @@ impl From for Error { } } -#[derive(Clone, Debug, Default, Eq, PartialEq)] -pub struct Scalar { - element: blst_scalar, -} - -impl Scalar { - pub const BITS: usize = 256; - pub const BYTES: usize = Self::BITS / 8; - - pub fn from_be_slice(bytes: impl AsRef<[u8]>) -> Option { - if bytes.as_ref().len() != Self::BYTES { - return None; - } - - let mut out = MaybeUninit::::uninit(); - unsafe { - blst_scalar_from_bendian(out.as_mut_ptr(), bytes.as_ref().as_ptr()); - Some(Self { - element: out.assume_init(), - }) - } - } - - pub fn to_be_bytes(&self) -> [u8; Self::BYTES] { - let mut out = [0; Self::BYTES]; - unsafe { - blst_bendian_from_scalar(out.as_mut_ptr(), &self.element); - } - out - } -} - -impl From for Scalar { - fn from(element: u64) -> Self { - let element = [element, 0, 0, 0]; - let mut out = MaybeUninit::::uninit(); - unsafe { - blst_scalar_from_uint64(out.as_mut_ptr(), element.as_ptr()); - Self { - element: out.assume_init(), - } - } - } -} - -impl From<&Fr> for Scalar { - fn from(element: &Fr) -> Self { - let mut out = MaybeUninit::::uninit(); - unsafe { - blst_scalar_from_fr(out.as_mut_ptr(), &element.element); - Self { - element: out.assume_init(), - } - } - } -} - -impl AsRef for Scalar { - fn as_ref(&self) -> &blst_scalar { - &self.element - } -} - #[derive(Clone, Copy, Debug, Default, Eq, PartialEq)] pub struct Fr { element: blst_fr, @@ -129,14 +65,6 @@ impl Fr { ], }, }; - pub const MODULUS: Scalar = Scalar { - element: blst_scalar { - b: [ - 1, 0, 0, 0, 255, 255, 255, 255, 254, 91, 254, 255, 2, 164, 189, 83, 5, 216, 161, 9, - 8, 216, 57, 51, 72, 125, 157, 41, 83, 167, 237, 115, - ], - }, - }; pub const MAX: Self = Self { element: blst_fr { l: [ @@ -150,11 +78,11 @@ impl Fr { pub const BITS: usize = 256; pub const BYTES: usize = Self::BITS / 8; - pub fn from_scalar(scalar: &Scalar) -> Option { + pub(crate) fn from_blst_scalar(scalar: blst_scalar) -> Option { let mut out = MaybeUninit::::uninit(); unsafe { - blst_scalar_fr_check(&scalar.element).then(|| { - blst_fr_from_scalar(out.as_mut_ptr(), &scalar.element); + blst_scalar_fr_check(&scalar).then(|| { + blst_fr_from_scalar(out.as_mut_ptr(), &scalar); Self { element: out.assume_init(), } @@ -166,17 +94,29 @@ impl Fr { let mut scalar = MaybeUninit::::uninit(); unsafe { blst_scalar_from_bendian(scalar.as_mut_ptr(), bytes.as_ref().as_ptr()); - Self::from_scalar(&Scalar { - element: scalar.assume_init(), - }) + Self::from_blst_scalar(scalar.assume_init()) } } pub fn from_be_slice(bytes: impl AsRef<[u8]>) -> Result { - let scalar = - Scalar::from_be_slice(bytes.as_ref()).ok_or(FiniteFieldError::InvalidEncoding)?; - let element = Self::from_scalar(&scalar).ok_or(FiniteFieldError::NotInFiniteField)?; - Ok(element) + if bytes.as_ref().len() != Self::BYTES { + return Err(FiniteFieldError::InvalidEncoding); + } + let mut scalar = MaybeUninit::::uninit(); + unsafe { + blst_scalar_from_bendian(scalar.as_mut_ptr(), bytes.as_ref().as_ptr()); + Self::from_blst_scalar(scalar.assume_init()).ok_or(FiniteFieldError::NotInFiniteField) + } + } + + pub fn to_be_bytes(self) -> [u8; Self::BYTES] { + let mut bytes = [0; Self::BYTES]; + let mut scalar = MaybeUninit::::uninit(); + unsafe { + blst_scalar_from_fr(scalar.as_mut_ptr(), &self.element); + blst_bendian_from_scalar(bytes.as_mut_ptr(), scalar.as_ptr()); + } + bytes } pub fn as_u64(&self) -> u64 { diff --git a/src/kzg/setup.rs b/src/kzg/setup.rs index d384520..755e3f6 100644 --- a/src/kzg/setup.rs +++ b/src/kzg/setup.rs @@ -111,7 +111,7 @@ impl Setup { assert_eq!(commitments.as_ref().len(), points.as_ref().len()); assert_eq!(points.as_ref().len(), evals.as_ref().len()); - const DOMAIN: &'static [u8; 16] = b"RCKZGBATCH___V1_"; + const DOMAIN: &[u8; 16] = b"RCKZGBATCH___V1_"; let degree = (G1 as u128).to_be_bytes(); let len = (proofs.as_ref().len() as u128).to_be_bytes();