Simplify precompile interface: remove gas_limit from PrecompileOutput, flatten PrecompileError

Remove gas_limit field from PrecompileOutput (only gas_used needed) and
eliminate the PrecompileError wrapper layer so errors are returned directly
as the enum variant without .into() conversion.

Author: rakita

crates/precompile/src/blake2.rs

@@ -15,21 +15,21 @@ pub const FUN: Precompile = Precompile::new(PrecompileId::Blake2F, crate::u64_to
 /// [4 bytes for rounds][64 bytes for h][128 bytes for m][8 bytes for t_0][8 bytes for t_1][1 byte for f]
 pub fn run(input: &[u8], gas_limit: u64) -> PrecompileResult {
     if input.len() != INPUT_LENGTH {
-        return Err(PrecompileError::Blake2WrongLength.into());
+        return Err(PrecompileError::Blake2WrongLength);
     }
 
     // Parse number of rounds (4 bytes)
     let rounds = u32::from_be_bytes(input[..4].try_into().unwrap());
     let gas_used = rounds as u64 * F_ROUND;
     if gas_used > gas_limit {
-        return Err(PrecompileError::OutOfGas.into());
+        return Err(PrecompileError::OutOfGas);
     }
 
     // Parse final block flag
     let f = match input[212] {
         0 => false,
         1 => true,
-        _ => return Err(PrecompileError::Blake2WrongFinalIndicatorFlag.into()),
+        _ => return Err(PrecompileError::Blake2WrongFinalIndicatorFlag),
     };
 
     // Parse state vector h (8 × u64)
@@ -61,7 +61,7 @@ pub fn run(input: &[u8], gas_limit: u64) -> PrecompileResult {
         out[i..i + 8].copy_from_slice(&h.to_le_bytes());
     }
 
-    Ok(PrecompileOutput::new(gas_limit, gas_used, out.into()))
+    Ok(PrecompileOutput::new(gas_used, out.into()))
 }
 
 /// Blake2 algorithm

crates/precompile/src/bls12_381/g1_add.rs

@@ -16,11 +16,11 @@ pub const PRECOMPILE: Precompile =
 /// See also: <https://eips.ethereum.org/EIPS/eip-2537#abi-for-g1-addition>
 pub fn g1_add(input: &[u8], gas_limit: u64) -> PrecompileResult {
     if G1_ADD_BASE_GAS_FEE > gas_limit {
-        return Err(PrecompileError::OutOfGas.into());
+        return Err(PrecompileError::OutOfGas);
     }
 
     if input.len() != G1_ADD_INPUT_LENGTH {
-        return Err(PrecompileError::Bls12381G1AddInputLength.into());
+        return Err(PrecompileError::Bls12381G1AddInputLength);
     }
 
     // Extract coordinates from padded input
@@ -36,7 +36,6 @@ pub fn g1_add(input: &[u8], gas_limit: u64) -> PrecompileResult {
     let padded_result = pad_g1_point(&unpadded_result);
 
     Ok(PrecompileOutput::new(
-        gas_limit,
         G1_ADD_BASE_GAS_FEE,
         padded_result.into(),
     ))

crates/precompile/src/bls12_381/g1_msm.rs

@@ -27,13 +27,13 @@ pub const PRECOMPILE: Precompile =
 pub fn g1_msm(input: &[u8], gas_limit: u64) -> PrecompileResult {
     let input_len = input.len();
     if input_len == 0 || !input_len.is_multiple_of(G1_MSM_INPUT_LENGTH) {
-        return Err(PrecompileError::Bls12381G1MsmInputLength.into());
+        return Err(PrecompileError::Bls12381G1MsmInputLength);
     }
 
     let k = input_len / G1_MSM_INPUT_LENGTH;
     let required_gas = msm_required_gas(k, &DISCOUNT_TABLE_G1_MSM, G1_MSM_BASE_GAS_FEE);
     if required_gas > gas_limit {
-        return Err(PrecompileError::OutOfGas.into());
+        return Err(PrecompileError::OutOfGas);
     }
 
     let mut valid_pairs_iter = (0..k).map(|i| {
@@ -54,11 +54,7 @@ pub fn g1_msm(input: &[u8], gas_limit: u64) -> PrecompileResult {
     // Pad the result for EVM compatibility
     let padded_result = pad_g1_point(&unpadded_result);
 
-    Ok(PrecompileOutput::new(
-        gas_limit,
-        required_gas,
-        padded_result.into(),
-    ))
+    Ok(PrecompileOutput::new(required_gas, padded_result.into()))
 }
 
 #[cfg(test)]
@@ -70,6 +66,6 @@ mod test {
     fn bls_g1multiexp_g1_not_on_curve_but_in_subgroup() {
         let input = Bytes::from(hex!("000000000000000000000000000000000a2833e497b38ee3ca5c62828bf4887a9f940c9e426c7890a759c20f248c23a7210d2432f4c98a514e524b5184a0ddac00000000000000000000000000000000150772d56bf9509469f9ebcd6e47570429fd31b0e262b66d512e245c38ec37255529f2271fd70066473e393a8bead0c30000000000000000000000000000000000000000000000000000000000000000"));
         let fail = g1_msm(&input, G1_MSM_BASE_GAS_FEE);
-        assert_eq!(fail, Err(PrecompileError::Bls12381G1NotOnCurve.into()));
+        assert_eq!(fail, Err(PrecompileError::Bls12381G1NotOnCurve));
     }
 }

crates/precompile/src/bls12_381/g2_add.rs

@@ -17,11 +17,11 @@ pub const PRECOMPILE: Precompile =
 /// See also <https://eips.ethereum.org/EIPS/eip-2537#abi-for-g2-addition>
 pub fn g2_add(input: &[u8], gas_limit: u64) -> PrecompileResult {
     if G2_ADD_BASE_GAS_FEE > gas_limit {
-        return Err(PrecompileError::OutOfGas.into());
+        return Err(PrecompileError::OutOfGas);
     }
 
     if input.len() != G2_ADD_INPUT_LENGTH {
-        return Err(PrecompileError::Bls12381G2AddInputLength.into());
+        return Err(PrecompileError::Bls12381G2AddInputLength);
     }
 
     // Extract coordinates from padded input
@@ -37,7 +37,6 @@ pub fn g2_add(input: &[u8], gas_limit: u64) -> PrecompileResult {
     let padded_result = pad_g2_point(&unpadded_result);
 
     Ok(PrecompileOutput::new(
-        gas_limit,
         G2_ADD_BASE_GAS_FEE,
         padded_result.into(),
     ))

crates/precompile/src/bls12_381/g2_msm.rs

@@ -24,13 +24,13 @@ pub const PRECOMPILE: Precompile =
 pub fn g2_msm(input: &[u8], gas_limit: u64) -> PrecompileResult {
     let input_len = input.len();
     if input_len == 0 || !input_len.is_multiple_of(G2_MSM_INPUT_LENGTH) {
-        return Err(PrecompileError::Bls12381G2MsmInputLength.into());
+        return Err(PrecompileError::Bls12381G2MsmInputLength);
     }
 
     let k = input_len / G2_MSM_INPUT_LENGTH;
     let required_gas = msm_required_gas(k, &DISCOUNT_TABLE_G2_MSM, G2_MSM_BASE_GAS_FEE);
     if required_gas > gas_limit {
-        return Err(PrecompileError::OutOfGas.into());
+        return Err(PrecompileError::OutOfGas);
     }
 
     let mut valid_pairs_iter = (0..k).map(|i| {
@@ -50,9 +50,5 @@ pub fn g2_msm(input: &[u8], gas_limit: u64) -> PrecompileResult {
     // Pad the result for EVM compatibility
     let padded_result = pad_g2_point(&unpadded_result);
 
-    Ok(PrecompileOutput::new(
-        gas_limit,
-        required_gas,
-        padded_result.into(),
-    ))
+    Ok(PrecompileOutput::new(required_gas, padded_result.into()))
 }

crates/precompile/src/bls12_381/map_fp2_to_g2.rs

@@ -20,11 +20,11 @@ pub const PRECOMPILE: Precompile = Precompile::new(
 /// See also: <https://eips.ethereum.org/EIPS/eip-2537#abi-for-mapping-fp2-element-to-g2-point>
 pub fn map_fp2_to_g2(input: &[u8], gas_limit: u64) -> PrecompileResult {
     if MAP_FP2_TO_G2_BASE_GAS_FEE > gas_limit {
-        return Err(PrecompileError::OutOfGas.into());
+        return Err(PrecompileError::OutOfGas);
     }
 
     if input.len() != PADDED_FP2_LENGTH {
-        return Err(PrecompileError::Bls12381MapFp2ToG2InputLength.into());
+        return Err(PrecompileError::Bls12381MapFp2ToG2InputLength);
     }
 
     let input_p0_x = remove_fp_padding(&input[..PADDED_FP_LENGTH])?;
@@ -36,7 +36,6 @@ pub fn map_fp2_to_g2(input: &[u8], gas_limit: u64) -> PrecompileResult {
     let padded_result = pad_g2_point(&unpadded_result);
 
     Ok(PrecompileOutput::new(
-        gas_limit,
         MAP_FP2_TO_G2_BASE_GAS_FEE,
         padded_result.into(),
     ))

crates/precompile/src/bls12_381/map_fp_to_g1.rs

@@ -17,11 +17,11 @@ pub const PRECOMPILE: Precompile = Precompile::new(
 /// See also: <https://eips.ethereum.org/EIPS/eip-2537#abi-for-mapping-fp-element-to-g1-point>
 pub fn map_fp_to_g1(input: &[u8], gas_limit: u64) -> PrecompileResult {
     if MAP_FP_TO_G1_BASE_GAS_FEE > gas_limit {
-        return Err(PrecompileError::OutOfGas.into());
+        return Err(PrecompileError::OutOfGas);
     }
 
     if input.len() != PADDED_FP_LENGTH {
-        return Err(PrecompileError::Bls12381MapFpToG1InputLength.into());
+        return Err(PrecompileError::Bls12381MapFpToG1InputLength);
     }
 
     let input_p0 = remove_fp_padding(input)?;
@@ -32,7 +32,6 @@ pub fn map_fp_to_g1(input: &[u8], gas_limit: u64) -> PrecompileResult {
     let padded_result = pad_g1_point(&unpadded_result);
 
     Ok(PrecompileOutput::new(
-        gas_limit,
         MAP_FP_TO_G1_BASE_GAS_FEE,
         padded_result.into(),
     ))
@@ -47,6 +46,6 @@ mod test {
     fn sanity_test() {
         let input = Bytes::from(hex!("000000000000000000000000000000006900000000000000636f6e7472616374595a603f343061cd305a03f40239f5ffff31818185c136bc2595f2aa18e08f17"));
         let fail = map_fp_to_g1(&input, MAP_FP_TO_G1_BASE_GAS_FEE);
-        assert_eq!(fail, Err(PrecompileError::NonCanonicalFp.into()));
+        assert_eq!(fail, Err(PrecompileError::NonCanonicalFp));
     }
 }

crates/precompile/src/bls12_381/pairing.rs

@@ -32,13 +32,13 @@ pub const PRECOMPILE: Precompile =
 pub fn pairing(input: &[u8], gas_limit: u64) -> PrecompileResult {
     let input_len = input.len();
     if input_len == 0 || !input_len.is_multiple_of(PAIRING_INPUT_LENGTH) {
-        return Err(PrecompileError::Bls12381PairingInputLength.into());
+        return Err(PrecompileError::Bls12381PairingInputLength);
     }
 
     let k = input_len / PAIRING_INPUT_LENGTH;
     let required_gas: u64 = PAIRING_MULTIPLIER_BASE * k as u64 + PAIRING_OFFSET_BASE;
     if required_gas > gas_limit {
-        return Err(PrecompileError::OutOfGas.into());
+        return Err(PrecompileError::OutOfGas);
     }
 
     // Collect pairs of points for the pairing check
@@ -59,7 +59,6 @@ pub fn pairing(input: &[u8], gas_limit: u64) -> PrecompileResult {
     let result = if result { 1 } else { 0 };
 
     Ok(PrecompileOutput::new(
-        gas_limit,
         required_gas,
         B256::with_last_byte(result).into(),
     ))

crates/precompile/src/bn254.rs

@@ -154,7 +154,7 @@ pub const PAIR_ELEMENT_LEN: usize = G1_LEN + G2_LEN;
 /// Run the Bn254 add precompile
 pub fn run_add(input: &[u8], gas_cost: u64, gas_limit: u64) -> PrecompileResult {
     if gas_cost > gas_limit {
-        return Err(PrecompileError::OutOfGas.into());
+        return Err(PrecompileError::OutOfGas);
     }
 
     let input = right_pad::<ADD_INPUT_LEN>(input);
@@ -163,13 +163,13 @@ pub fn run_add(input: &[u8], gas_cost: u64, gas_limit: u64) -> PrecompileResult
     let p2_bytes = &input[G1_LEN..];
     let output = crypto().bn254_g1_add(p1_bytes, p2_bytes)?;
 
-    Ok(PrecompileOutput::new(gas_limit, gas_cost, output.into()))
+    Ok(PrecompileOutput::new(gas_cost, output.into()))
 }
 
 /// Run the Bn254 mul precompile
 pub fn run_mul(input: &[u8], gas_cost: u64, gas_limit: u64) -> PrecompileResult {
     if gas_cost > gas_limit {
-        return Err(PrecompileError::OutOfGas.into());
+        return Err(PrecompileError::OutOfGas);
     }
 
     let input = right_pad::<MUL_INPUT_LEN>(input);
@@ -178,7 +178,7 @@ pub fn run_mul(input: &[u8], gas_cost: u64, gas_limit: u64) -> PrecompileResult
     let scalar_bytes = &input[G1_LEN..G1_LEN + SCALAR_LEN];
     let output = crypto().bn254_g1_mul(point_bytes, scalar_bytes)?;
 
-    Ok(PrecompileOutput::new(gas_limit, gas_cost, output.into()))
+    Ok(PrecompileOutput::new(gas_cost, output.into()))
 }
 
 /// Run the Bn254 pair precompile
@@ -190,11 +190,11 @@ pub fn run_pair(
 ) -> PrecompileResult {
     let gas_used = (input.len() / PAIR_ELEMENT_LEN) as u64 * pair_per_point_cost + pair_base_cost;
     if gas_used > gas_limit {
-        return Err(PrecompileError::OutOfGas.into());
+        return Err(PrecompileError::OutOfGas);
     }
 
     if !input.len().is_multiple_of(PAIR_ELEMENT_LEN) {
-        return Err(PrecompileError::Bn254PairLength.into());
+        return Err(PrecompileError::Bn254PairLength);
     }
 
     let elements = input.len() / PAIR_ELEMENT_LEN;
@@ -217,7 +217,6 @@ pub fn run_pair(
 
     let pairing_result = crypto().bn254_pairing_check(&points)?;
     Ok(PrecompileOutput::new(
-        gas_limit,
         gas_used,
         bool_to_bytes32(pairing_result),
     ))
@@ -288,7 +287,7 @@ mod tests {
 
         let res = run_add(&input, BYZANTIUM_ADD_GAS_COST, 499);
 
-        assert!(matches!(res, Err(ref f) if f.error == PrecompileError::OutOfGas));
+        assert!(matches!(res, Err(ref f) if *f == PrecompileError::OutOfGas));
 
         // No input test
         let input = [0u8; 0];
@@ -315,7 +314,7 @@ mod tests {
         let res = run_add(&input, BYZANTIUM_ADD_GAS_COST, 500);
         assert!(matches!(
             res,
-            Err(ref f) if f.error == PrecompileError::Bn254AffineGFailedToCreate
+            Err(ref f) if *f == PrecompileError::Bn254AffineGFailedToCreate
         ));
     }
 
@@ -348,7 +347,7 @@ mod tests {
         .unwrap();
 
         let res = run_mul(&input, BYZANTIUM_MUL_GAS_COST, 39_999);
-        assert!(matches!(res, Err(ref f) if f.error == PrecompileError::OutOfGas));
+        assert!(matches!(res, Err(ref f) if *f == PrecompileError::OutOfGas));
 
         // Zero multiplication test
         let input = hex::decode(
@@ -392,7 +391,7 @@ mod tests {
         let res = run_mul(&input, BYZANTIUM_MUL_GAS_COST, 40_000);
         assert!(matches!(
             res,
-            Err(ref f) if f.error == PrecompileError::Bn254AffineGFailedToCreate
+            Err(ref f) if *f == PrecompileError::Bn254AffineGFailedToCreate
         ));
     }
 
@@ -451,7 +450,7 @@ mod tests {
             BYZANTIUM_PAIR_BASE,
             259_999,
         );
-        assert!(matches!(res, Err(ref f) if f.error == PrecompileError::OutOfGas));
+        assert!(matches!(res, Err(ref f) if *f == PrecompileError::OutOfGas));
 
         // No input test
         let input = [0u8; 0];
@@ -488,7 +487,7 @@ mod tests {
         );
         assert!(matches!(
             res,
-            Err(ref f) if f.error == PrecompileError::Bn254AffineGFailedToCreate
+            Err(ref f) if *f == PrecompileError::Bn254AffineGFailedToCreate
         ));
 
         // Invalid input length
@@ -507,7 +506,7 @@ mod tests {
             BYZANTIUM_PAIR_BASE,
             260_000,
         );
-        assert!(matches!(res, Err(ref f) if f.error == PrecompileError::Bn254PairLength));
+        assert!(matches!(res, Err(ref f) if *f == PrecompileError::Bn254PairLength));
 
         // Test with point at infinity - should return true (identity element)
         // G1 point at infinity (0,0) followed by a valid G2 point

crates/precompile/src/hash.rs

@@ -25,14 +25,10 @@ pub const RIPEMD160: Precompile = Precompile::new(
 pub fn sha256_run(input: &[u8], gas_limit: u64) -> PrecompileResult {
     let cost = calc_linear_cost(input.len(), 60, 12);
     if cost > gas_limit {
-        Err(PrecompileError::OutOfGas.into())
+        Err(PrecompileError::OutOfGas)
     } else {
         let output = crypto().sha256(input);
-        Ok(PrecompileOutput::new(
-            gas_limit,
-            cost,
-            output.to_vec().into(),
-        ))
+        Ok(PrecompileOutput::new(cost, output.to_vec().into()))
     }
 }
 
@@ -45,13 +41,9 @@ pub fn sha256_run(input: &[u8], gas_limit: u64) -> PrecompileResult {
 pub fn ripemd160_run(input: &[u8], gas_limit: u64) -> PrecompileResult {
     let gas_used = calc_linear_cost(input.len(), 600, 120);
     if gas_used > gas_limit {
-        Err(PrecompileError::OutOfGas.into())
+        Err(PrecompileError::OutOfGas)
     } else {
         let output = crypto().ripemd160(input);
-        Ok(PrecompileOutput::new(
-            gas_limit,
-            gas_used,
-            output.to_vec().into(),
-        ))
+        Ok(PrecompileOutput::new(gas_used, output.to_vec().into()))
     }
 }