chore: Remove redundant bls12-381 constants and cleanup naming (#2235)

* remove G1_OUTPUT_LENGTH

* remove G1_INPUT_ITEM_LENGTH

* remove G2_OUTPUT_LENGTH and G2_INPUT_ITEM_LENGTH

* PADDING_LENGTH -> FP_PADDING_LENGTH

* PAIRING_PAIRING -> PAIRING

* comment -> doc comment

* cargo fmt

Author: kevaundray

crates/precompile/src/bls12_381/g1.rs

@@ -1,12 +1,12 @@
 use super::utils::{fp_from_bendian, fp_to_bytes, remove_padding};
-use crate::bls12_381_const::{G1_INPUT_ITEM_LENGTH, G1_OUTPUT_LENGTH, PADDED_FP_LENGTH};
+use crate::bls12_381_const::{PADDED_FP_LENGTH, PADDED_G1_LENGTH};
 use crate::PrecompileError;
 use blst::{blst_p1_affine, blst_p1_affine_in_g1, blst_p1_affine_on_curve};
 use primitives::Bytes;
 
 /// Encodes a G1 point in affine format into byte slice with padded elements.
 pub(super) fn encode_g1_point(input: *const blst_p1_affine) -> Bytes {
-    let mut out = vec![0u8; G1_OUTPUT_LENGTH];
+    let mut out = vec![0u8; PADDED_G1_LENGTH];
     // SAFETY: Out comes from fixed length array, input is a blst value.
     unsafe {
         fp_to_bytes(&mut out[..PADDED_FP_LENGTH], &(*input).x);
@@ -40,15 +40,15 @@ pub(super) fn extract_g1_input(
     input: &[u8],
     subgroup_check: bool,
 ) -> Result<blst_p1_affine, PrecompileError> {
-    if input.len() != G1_INPUT_ITEM_LENGTH {
+    if input.len() != PADDED_G1_LENGTH {
         return Err(PrecompileError::Other(format!(
-            "Input should be {G1_INPUT_ITEM_LENGTH} bytes, was {}",
+            "Input should be {PADDED_G1_LENGTH} bytes, was {}",
             input.len()
         )));
     }
 
     let input_p0_x = remove_padding(&input[..PADDED_FP_LENGTH])?;
-    let input_p0_y = remove_padding(&input[PADDED_FP_LENGTH..G1_INPUT_ITEM_LENGTH])?;
+    let input_p0_y = remove_padding(&input[PADDED_FP_LENGTH..PADDED_G1_LENGTH])?;
     let out = decode_and_check_g1(input_p0_x, input_p0_y)?;
 
     // From EIP-2537:

crates/precompile/src/bls12_381/g1_add.rs

@@ -1,6 +1,6 @@
 use super::g1::{encode_g1_point, extract_g1_input};
 use crate::bls12_381_const::{
-    G1_ADD_ADDRESS, G1_ADD_BASE_GAS_FEE, G1_ADD_INPUT_LENGTH, G1_INPUT_ITEM_LENGTH,
+    G1_ADD_ADDRESS, G1_ADD_BASE_GAS_FEE, G1_ADD_INPUT_LENGTH, PADDED_G1_LENGTH,
 };
 use crate::{u64_to_address, PrecompileWithAddress};
 use crate::{PrecompileError, PrecompileOutput, PrecompileResult};
@@ -33,8 +33,8 @@ pub(super) fn g1_add(input: &Bytes, gas_limit: u64) -> PrecompileResult {
     // NB: There is no subgroup check for the G1 addition precompile.
     //
     // So we set the subgroup checks here to `false`
-    let a_aff = &extract_g1_input(&input[..G1_INPUT_ITEM_LENGTH], false)?;
-    let b_aff = &extract_g1_input(&input[G1_INPUT_ITEM_LENGTH..], false)?;
+    let a_aff = &extract_g1_input(&input[..PADDED_G1_LENGTH], false)?;
+    let b_aff = &extract_g1_input(&input[PADDED_G1_LENGTH..], false)?;
 
     let mut b = blst_p1::default();
     // SAFETY: `b` and `b_aff` are blst values.

crates/precompile/src/bls12_381/g1_msm.rs

@@ -3,8 +3,8 @@ use super::{
     utils::extract_scalar_input,
 };
 use crate::bls12_381_const::{
-    DISCOUNT_TABLE_G1_MSM, G1_INPUT_ITEM_LENGTH, G1_MSM_ADDRESS, G1_MSM_BASE_GAS_FEE,
-    G1_MSM_INPUT_LENGTH, NBITS, SCALAR_LENGTH,
+    DISCOUNT_TABLE_G1_MSM, G1_MSM_ADDRESS, G1_MSM_BASE_GAS_FEE, G1_MSM_INPUT_LENGTH, NBITS,
+    PADDED_G1_LENGTH, SCALAR_LENGTH,
 };
 use crate::bls12_381_utils::msm_required_gas;
 use crate::{u64_to_address, PrecompileWithAddress};
@@ -42,7 +42,7 @@ pub(super) fn g1_msm(input: &Bytes, gas_limit: u64) -> PrecompileResult {
     let mut g1_points: Vec<blst_p1> = Vec::with_capacity(k);
     let mut scalars: Vec<u8> = Vec::with_capacity(k * SCALAR_LENGTH);
     for i in 0..k {
-        let slice = &input[i * G1_MSM_INPUT_LENGTH..i * G1_MSM_INPUT_LENGTH + G1_INPUT_ITEM_LENGTH];
+        let slice = &input[i * G1_MSM_INPUT_LENGTH..i * G1_MSM_INPUT_LENGTH + PADDED_G1_LENGTH];
 
         // BLST batch API for p1_affines blows up when you pass it a point at infinity, so we must
         // filter points at infinity (and their corresponding scalars) from the input.
@@ -62,8 +62,8 @@ pub(super) fn g1_msm(input: &Bytes, gas_limit: u64) -> PrecompileResult {
 
         scalars.extend_from_slice(
             &extract_scalar_input(
-                &input[i * G1_MSM_INPUT_LENGTH + G1_INPUT_ITEM_LENGTH
-                    ..i * G1_MSM_INPUT_LENGTH + G1_INPUT_ITEM_LENGTH + SCALAR_LENGTH],
+                &input[i * G1_MSM_INPUT_LENGTH + PADDED_G1_LENGTH
+                    ..i * G1_MSM_INPUT_LENGTH + PADDED_G1_LENGTH + SCALAR_LENGTH],
             )?
             .b,
         );

crates/precompile/src/bls12_381/g2.rs

@@ -1,12 +1,12 @@
 use super::utils::{fp_from_bendian, fp_to_bytes, remove_padding};
-use crate::bls12_381_const::{FP_LENGTH, G2_INPUT_ITEM_LENGTH, G2_OUTPUT_LENGTH, PADDED_FP_LENGTH};
+use crate::bls12_381_const::{FP_LENGTH, PADDED_FP_LENGTH, PADDED_G2_LENGTH};
 use crate::PrecompileError;
 use blst::{blst_fp2, blst_p2_affine, blst_p2_affine_in_g2, blst_p2_affine_on_curve};
 use primitives::Bytes;
 
 /// Encodes a G2 point in affine format into byte slice with padded elements.
 pub(super) fn encode_g2_point(input: &blst_p2_affine) -> Bytes {
-    let mut out = vec![0u8; G2_OUTPUT_LENGTH];
+    let mut out = vec![0u8; PADDED_G2_LENGTH];
     fp_to_bytes(&mut out[..PADDED_FP_LENGTH], &input.x.fp[0]);
     fp_to_bytes(
         &mut out[PADDED_FP_LENGTH..2 * PADDED_FP_LENGTH],
@@ -57,9 +57,9 @@ pub(super) fn extract_g2_input(
     input: &[u8],
     subgroup_check: bool,
 ) -> Result<blst_p2_affine, PrecompileError> {
-    if input.len() != G2_INPUT_ITEM_LENGTH {
+    if input.len() != PADDED_G2_LENGTH {
         return Err(PrecompileError::Other(format!(
-            "Input should be {G2_INPUT_ITEM_LENGTH} bytes, was {}",
+            "Input should be {PADDED_G2_LENGTH} bytes, was {}",
             input.len()
         )));
     }

crates/precompile/src/bls12_381/g2_add.rs

@@ -1,6 +1,6 @@
 use super::g2::{encode_g2_point, extract_g2_input};
 use crate::bls12_381_const::{
-    G2_ADD_ADDRESS, G2_ADD_BASE_GAS_FEE, G2_ADD_INPUT_LENGTH, G2_INPUT_ITEM_LENGTH,
+    G2_ADD_ADDRESS, G2_ADD_BASE_GAS_FEE, G2_ADD_INPUT_LENGTH, PADDED_G2_LENGTH,
 };
 use crate::{u64_to_address, PrecompileWithAddress};
 use crate::{PrecompileError, PrecompileOutput, PrecompileResult};
@@ -34,8 +34,8 @@ pub(super) fn g2_add(input: &Bytes, gas_limit: u64) -> PrecompileResult {
     // NB: There is no subgroup check for the G2 addition precompile.
     //
     // So we set the subgroup checks here to `false`
-    let a_aff = &extract_g2_input(&input[..G2_INPUT_ITEM_LENGTH], false)?;
-    let b_aff = &extract_g2_input(&input[G2_INPUT_ITEM_LENGTH..], false)?;
+    let a_aff = &extract_g2_input(&input[..PADDED_G2_LENGTH], false)?;
+    let b_aff = &extract_g2_input(&input[PADDED_G2_LENGTH..], false)?;
 
     let mut b = blst_p2::default();
     // SAFETY: `b` and `b_aff` are blst values.

crates/precompile/src/bls12_381/g2_msm.rs

@@ -3,8 +3,8 @@ use super::{
     utils::extract_scalar_input,
 };
 use crate::bls12_381_const::{
-    DISCOUNT_TABLE_G2_MSM, G2_INPUT_ITEM_LENGTH, G2_MSM_ADDRESS, G2_MSM_BASE_GAS_FEE,
-    G2_MSM_INPUT_LENGTH, NBITS, SCALAR_LENGTH,
+    DISCOUNT_TABLE_G2_MSM, G2_MSM_ADDRESS, G2_MSM_BASE_GAS_FEE, G2_MSM_INPUT_LENGTH, NBITS,
+    PADDED_G2_LENGTH, SCALAR_LENGTH,
 };
 use crate::bls12_381_utils::msm_required_gas;
 use crate::{u64_to_address, PrecompileWithAddress};
@@ -42,7 +42,7 @@ pub(super) fn g2_msm(input: &Bytes, gas_limit: u64) -> PrecompileResult {
     let mut g2_points: Vec<blst_p2> = Vec::with_capacity(k);
     let mut scalars: Vec<u8> = Vec::with_capacity(k * SCALAR_LENGTH);
     for i in 0..k {
-        let slice = &input[i * G2_MSM_INPUT_LENGTH..i * G2_MSM_INPUT_LENGTH + G2_INPUT_ITEM_LENGTH];
+        let slice = &input[i * G2_MSM_INPUT_LENGTH..i * G2_MSM_INPUT_LENGTH + PADDED_G2_LENGTH];
         // BLST batch API for p2_affines blows up when you pass it a point at infinity, so we must
         // filter points at infinity (and their corresponding scalars) from the input.
         if slice.iter().all(|i| *i == 0) {
@@ -62,8 +62,8 @@ pub(super) fn g2_msm(input: &Bytes, gas_limit: u64) -> PrecompileResult {
 
         scalars.extend_from_slice(
             &extract_scalar_input(
-                &input[i * G2_MSM_INPUT_LENGTH + G2_INPUT_ITEM_LENGTH
-                    ..i * G2_MSM_INPUT_LENGTH + G2_INPUT_ITEM_LENGTH + SCALAR_LENGTH],
+                &input[i * G2_MSM_INPUT_LENGTH + PADDED_G2_LENGTH
+                    ..i * G2_MSM_INPUT_LENGTH + PADDED_G2_LENGTH + SCALAR_LENGTH],
             )?
             .b,
         );

crates/precompile/src/bls12_381/pairing.rs

@@ -1,7 +1,7 @@
 use super::{g1::extract_g1_input, g2::extract_g2_input};
 use crate::bls12_381_const::{
-    G1_INPUT_ITEM_LENGTH, G2_INPUT_ITEM_LENGTH, PAIRING_ADDRESS, PAIRING_INPUT_LENGTH,
-    PAIRING_PAIRING_MULTIPLIER_BASE, PAIRING_PAIRING_OFFSET_BASE,
+    PADDED_G1_LENGTH, PADDED_G2_LENGTH, PAIRING_ADDRESS, PAIRING_INPUT_LENGTH,
+    PAIRING_MULTIPLIER_BASE, PAIRING_OFFSET_BASE,
 };
 use crate::{
     u64_to_address, PrecompileError, PrecompileOutput, PrecompileResult, PrecompileWithAddress,
@@ -34,8 +34,7 @@ pub(super) fn pairing(input: &Bytes, gas_limit: u64) -> PrecompileResult {
     }
 
     let k = input_len / PAIRING_INPUT_LENGTH;
-    let required_gas: u64 =
-        PAIRING_PAIRING_MULTIPLIER_BASE * k as u64 + PAIRING_PAIRING_OFFSET_BASE;
+    let required_gas: u64 = PAIRING_MULTIPLIER_BASE * k as u64 + PAIRING_OFFSET_BASE;
     if required_gas > gas_limit {
         return Err(PrecompileError::OutOfGas);
     }
@@ -47,16 +46,16 @@ pub(super) fn pairing(input: &Bytes, gas_limit: u64) -> PrecompileResult {
         //
         // So we set the subgroup_check flag to `true`
         let p1_aff = &extract_g1_input(
-            &input[i * PAIRING_INPUT_LENGTH..i * PAIRING_INPUT_LENGTH + G1_INPUT_ITEM_LENGTH],
+            &input[i * PAIRING_INPUT_LENGTH..i * PAIRING_INPUT_LENGTH + PADDED_G1_LENGTH],
             true,
         )?;
 
         // NB: Scalar multiplications, MSMs and pairings MUST perform a subgroup check.
         //
         // So we set the subgroup_check flag to `true`
         let p2_aff = &extract_g2_input(
-            &input[i * PAIRING_INPUT_LENGTH + G1_INPUT_ITEM_LENGTH
-                ..i * PAIRING_INPUT_LENGTH + G1_INPUT_ITEM_LENGTH + G2_INPUT_ITEM_LENGTH],
+            &input[i * PAIRING_INPUT_LENGTH + PADDED_G1_LENGTH
+                ..i * PAIRING_INPUT_LENGTH + PADDED_G1_LENGTH + PADDED_G2_LENGTH],
             true,
         )?;
 

crates/precompile/src/bls12_381/utils.rs

@@ -1,6 +1,4 @@
-use crate::bls12_381_const::{
-    FP_LENGTH, MODULUS_REPR, PADDED_FP_LENGTH, PADDING_LENGTH, SCALAR_LENGTH,
-};
+use crate::bls12_381_const::{FP_LENGTH, FP_PAD_BY, MODULUS_REPR, PADDED_FP_LENGTH, SCALAR_LENGTH};
 use crate::PrecompileError;
 use blst::{
     blst_bendian_from_fp, blst_fp, blst_fp_from_bendian, blst_scalar, blst_scalar_from_bendian,
@@ -12,7 +10,7 @@ pub(super) fn fp_to_bytes(out: &mut [u8], input: *const blst_fp) {
     if out.len() != PADDED_FP_LENGTH {
         return;
     }
-    let (padding, rest) = out.split_at_mut(PADDING_LENGTH);
+    let (padding, rest) = out.split_at_mut(FP_PAD_BY);
     padding.fill(0);
     // SAFETY: Out length is checked previously, `input` is a blst value.
     unsafe { blst_bendian_from_fp(rest.as_mut_ptr(), input) };
@@ -26,10 +24,10 @@ pub(super) fn remove_padding(input: &[u8]) -> Result<&[u8; FP_LENGTH], Precompil
             input.len()
         )));
     }
-    let (padding, unpadded) = input.split_at(PADDING_LENGTH);
+    let (padding, unpadded) = input.split_at(FP_PAD_BY);
     if !padding.iter().all(|&x| x == 0) {
         return Err(PrecompileError::Other(format!(
-            "{PADDING_LENGTH} top bytes of input are not zero",
+            "{FP_PAD_BY} top bytes of input are not zero",
         )));
     }
     Ok(unpadded.try_into().unwrap())

crates/precompile/src/bls12_381_const.rs

@@ -12,11 +12,9 @@ pub const G2_ADD_BASE_GAS_FEE: u64 = 600;
 pub const G2_MSM_ADDRESS: u64 = 0x0e;
 pub const G2_MSM_BASE_GAS_FEE: u64 = 22500;
 pub const PAIRING_ADDRESS: u64 = 0x0f;
-// TODO: Why does this have PAIRING twice?
-pub const PAIRING_PAIRING_OFFSET_BASE: u64 = 37700;
+pub const PAIRING_OFFSET_BASE: u64 = 37700;
 pub const MSM_MULTIPLIER: u64 = 1000;
-// TODO: Why does this have PAIRING twice?
-pub const PAIRING_PAIRING_MULTIPLIER_BASE: u64 = 32600;
+pub const PAIRING_MULTIPLIER_BASE: u64 = 32600;
 
 /// Discounts table for G1 MSM as a vector of pairs `[k, discount]`.
 pub static DISCOUNT_TABLE_G1_MSM: [u16; 128] = [
@@ -28,7 +26,7 @@ pub static DISCOUNT_TABLE_G1_MSM: [u16; 128] = [
     544, 543, 542, 541, 540, 540, 539, 538, 537, 536, 536, 535, 534, 533, 532, 532, 531, 530, 529,
     528, 528, 527, 526, 525, 525, 524, 523, 522, 522, 521, 520, 520, 519,
 ];
-// Discounts table for G2 MSM as a vector of pairs `[k, discount]`:
+/// Discounts table for G2 MSM as a vector of pairs `[k, discount]`:
 pub static DISCOUNT_TABLE_G2_MSM: [u16; 128] = [
     1000, 1000, 923, 884, 855, 832, 812, 796, 782, 770, 759, 749, 740, 732, 724, 717, 711, 704,
     699, 693, 688, 683, 679, 674, 670, 666, 663, 659, 655, 652, 649, 646, 643, 640, 637, 634, 632,
@@ -83,19 +81,11 @@ pub const NBITS: usize = 256;
 ///
 /// Note: The input to the G1 addition precompile is 2 G1 elements.
 pub const G1_ADD_INPUT_LENGTH: usize = 2 * PADDED_G1_LENGTH;
-/// G1_OUTPUT_LENGTH specifies the number of bytes that the EVM will use
-/// to represent a G1 element.
-// TODO: can we remove this since it is just `PADDED_G1_LENGTH`?
-pub const G1_OUTPUT_LENGTH: usize = PADDED_G1_LENGTH;
 /// G1_MSM_INPUT_LENGTH specifies the number of bytes that each MSM input pair should have.
 ///
 /// Note: An MSM pair is a G1 element and a scalar. The input to the MSM precompile will have `n`
 /// of these pairs.
 pub const G1_MSM_INPUT_LENGTH: usize = PADDED_G1_LENGTH + SCALAR_LENGTH;
-/// G1_INPUT_ITEM_LENGTH specifies the number of bytes that the EVM will use to represent
-/// a G1 element.
-// TODO: can we remove this since it is just `PADDED_G1_LENGTH`?
-pub const G1_INPUT_ITEM_LENGTH: usize = PADDED_G1_LENGTH;
 
 /// PADDED_G2_LENGTH specifies the number of bytes that the EVM will use to represent
 /// a G2 element.
@@ -113,26 +103,17 @@ pub const G2_ADD_INPUT_LENGTH: usize = 2 * PADDED_G2_LENGTH;
 /// Note: An MSM pair is a G2 element and a scalar. The input to the MSM will have `n`
 /// of these pairs.
 pub const G2_MSM_INPUT_LENGTH: usize = PADDED_G2_LENGTH + SCALAR_LENGTH;
-/// G2_OUTPUT_LENGTH specifies the number of bytes that the EVM will use
-/// to represent a G2 element.
-// TODO: can we remove this since it is just `PADDED_G2_LENGTH`
-pub const G2_OUTPUT_LENGTH: usize = PADDED_G2_LENGTH;
-/// G2_INPUT_ITEM_LENGTH specifies the number of bytes that the EVM will use to represent
-/// a G2 element.
-// TODO: can we remove this since it is just `PADDED_G2_LENGTH`
-pub const G2_INPUT_ITEM_LENGTH: usize = 256;
 
 /// PAIRING_INPUT_LENGTH specifies the number of bytes that each Pairing input pair should have.
 ///
 /// Note: An Pairing input-pair is a G2 element and a G1 element. The input to the Pairing will have `n`
 /// of these pairs.
 pub const PAIRING_INPUT_LENGTH: usize = PADDED_G1_LENGTH + PADDED_G2_LENGTH;
 
-/// PADDING_LENGTH specifies the number of bytes that an FP_ELEMENT is padded by.
+/// FP_PAD_BY specifies the number of bytes that an FP_ELEMENT is padded by to make it 32 byte aligned.
 ///
 /// Note: This should be equal to PADDED_FP_LENGTH - FP_LENGTH.
-/// TODO: Should likely rename this to FP_PADDING_LENGTH, since other objects are also padded
-pub const PADDING_LENGTH: usize = 16;
+pub const FP_PAD_BY: usize = 16;
 
 // Big-endian non-Montgomery form.
 pub const MODULUS_REPR: [u8; 48] = [