Added u128_bound function removing some minor calculations. (#9390)

Author: orizi

crates/cairo-lang-sierra-to-casm/src/invocations/gas_reserve.rs

@@ -1,9 +1,8 @@
 use cairo_lang_casm::builder::{CasmBuilder, Var};
 use cairo_lang_casm::casm_build_extend;
 use cairo_lang_sierra::extensions::gas_reserve::GasReserveConcreteLibfunc;
-use num_bigint::BigInt;
 
-use crate::invocations::int::SmallDiffHelper;
+use crate::invocations::int::{SmallDiffHelper, u128_bound};
 use crate::invocations::{
     CompiledInvocation, CompiledInvocationBuilder, InvocationError, add_input_variables,
 };
@@ -23,7 +22,7 @@ pub fn build(
 fn build_gas_reserve_create(
     builder: CompiledInvocationBuilder<'_>,
 ) -> Result<CompiledInvocation, InvocationError> {
-    let data = SmallDiffHelper::new(builder, BigInt::from(u128::MAX) + BigInt::from(1))?;
+    let data = SmallDiffHelper::new(builder, u128_bound().clone())?;
     let no_overflow_res: &[&[Var]] = &[&[data.range_check], &[data.a_minus_b], &[data.b]];
     let overflow_res: &[&[Var]] = &[&[data.range_check], &[data.a]];
     data.finalize(no_overflow_res, overflow_res)

crates/cairo-lang-sierra-to-casm/src/invocations/int/mod.rs

@@ -1,3 +1,5 @@
+use std::sync::LazyLock;
+
 use cairo_lang_casm::builder::{CasmBuilder, Var};
 use cairo_lang_casm::casm_build_extend;
 use cairo_lang_casm::cell_expression::CellExpression;
@@ -19,6 +21,12 @@ pub mod unsigned128;
 pub mod unsigned256;
 pub mod unsigned512;
 
+/// The value of 2^128.
+pub fn u128_bound() -> &'static BigInt {
+    static U128_BOUND: LazyLock<BigInt> = LazyLock::new(|| BigInt::from(1) << 128);
+    &U128_BOUND
+}
+
 /// Builds invocations for uint const values.
 fn build_const<TIntTraits: IntTraits>(
     libfunc: &IntConstConcreteLibfunc<TIntTraits>,
@@ -79,7 +87,7 @@ impl<'a> SmallDiffHelper<'a> {
             let orig_range_check = range_check;
             tempvar a_ge_b;
             tempvar a_minus_b = a - b;
-            const u128_limit = BigInt::from(u128::MAX) + BigInt::from(1);
+            const u128_limit = u128_bound().clone();
             const limit = limit;
             hint TestLessThan {lhs: a_minus_b, rhs: limit} into {dst: a_ge_b};
             jump NoOverflow if a_ge_b != 0;

crates/cairo-lang-sierra-to-casm/src/invocations/int/signed.rs

@@ -7,7 +7,7 @@ use cairo_lang_sierra::extensions::utils::Range;
 use cairo_lang_sierra::program::{BranchInfo, BranchTarget};
 use num_bigint::BigInt;
 
-use super::{add_input_variables, build_const, build_small_diff, build_small_wide_mul};
+use super::{add_input_variables, build_const, build_small_diff, build_small_wide_mul, u128_bound};
 use crate::invocations::range_reduction::build_felt252_range_reduction;
 use crate::invocations::{
     BuiltinInfo, CompiledInvocation, CompiledInvocationBuilder, CostValidationInfo,
@@ -77,7 +77,7 @@ pub fn build_sint_overflowing_operation(
         // Bound for addition or subtraction of any 2 numbers in [i128::MIN, i128::MAX].
         // max(2 * i128::MAX, i128::MAX - i128::MIN) + 1
         // ==> max(2*(2**127 - 1), 2**127 - 1 -(-2**127)) + 1 ==> 2**128
-        const above_bound = BigInt::from(u128::MAX) + BigInt::from(1);
+        const above_bound = u128_bound().clone();
         hint TestLessThan {lhs: value, rhs: above_bound} into {dst: is_above};
         jump IsAbove if is_above != 0;
         // Below range case.

crates/cairo-lang-sierra-to-casm/src/invocations/int/unsigned128.rs

@@ -7,7 +7,7 @@ use cairo_lang_sierra::extensions::utils::Range;
 use num_bigint::BigInt;
 use num_traits::{Num, One};
 
-use super::{bounded, build_128bit_diff, build_const};
+use super::{bounded, build_128bit_diff, build_const, u128_bound};
 use crate::invocations::{
     BuiltinInfo, CompiledInvocation, CompiledInvocationBuilder, CostValidationInfo,
     InvocationError, add_input_variables, bitwise, get_non_fallthrough_statement_id, misc,
@@ -25,8 +25,8 @@ pub fn build(
         },
         Uint128Concrete::Divmod(_) => bounded::build_div_rem(
             builder,
-            &Range::closed(0, u128::MAX),
-            &Range::closed(1, u128::MAX),
+            &Range::half_open(0, u128_bound().clone()),
+            &Range::half_open(1, u128_bound().clone()),
         ),
         Uint128Concrete::GuaranteeMul(_) => build_u128_guarantee_mul(builder),
         Uint128Concrete::MulGuaranteeVerify(_) => build_u128_mul_guarantee_verify(builder),
@@ -57,7 +57,7 @@ fn build_u128_overflowing_add(
             let orig_range_check = range_check;
             tempvar no_overflow;
             tempvar a_plus_b = a + b;
-            const u128_limit = (BigInt::from(u128::MAX) + 1) as BigInt;
+            const u128_limit = u128_bound().clone();
             hint TestLessThan {lhs: a_plus_b, rhs: u128_limit} into {dst: no_overflow};
             jump NoOverflow if no_overflow != 0;
             // Overflow:
@@ -194,7 +194,7 @@ fn build_u128_mul_guarantee_verify(
         // Note that `lower_uint128_with_carry` is bounded by 193 bits, as `a0_b` is capped
         // at 192 bits and `shifted_a1_b0_bottom` can contribute at most 1 additional bit,
         // added to (the carry of) `lower_uint128_with_carry = a0_b + shifted_a1_b0_bottom`.
-        const u128_limit = (BigInt::from(u128::MAX) + 1) as BigInt;
+        const u128_limit = u128_bound().clone();
         hint DivMod {
             lhs: lower_uint128_with_carry,
             rhs: u128_limit
@@ -239,7 +239,7 @@ fn build_u128_from_felt252(
     let value = expr_value.try_unpack_single()?;
 
     let failure_handle_statement_id = get_non_fallthrough_statement_id(&builder);
-    let u128_bound: BigInt = BigInt::from(u128::MAX) + 1; // = 2**128.
+    let u128_bound = u128_bound(); // = 2**128.
     // Represent the maximal possible value (PRIME - 1) as 2**128 * max_x + max_y.
     let max_x: i128 = 10633823966279327296825105735305134080;
     let max_y: i128 = 0;
@@ -275,7 +275,7 @@ fn build_u128_from_felt252(
             assert x_minus_max_x = x + minus_max_x;
             jump XNotMaxX if x_minus_max_x != 0;
             // If x == max_x, check that y <= max_y.
-            const le_max_y_fix = (u128_bound.clone() - max_y - 1) as BigInt;
+            const le_max_y_fix = (u128_bound - max_y - 1) as BigInt;
             assert rced_value = y + le_max_y_fix;
             jump WriteRcedValue;
         XNotMaxX:

crates/cairo-lang-sierra-to-casm/src/invocations/range.rs

@@ -2,9 +2,9 @@ use cairo_lang_casm::builder::CasmBuilder;
 use cairo_lang_casm::casm_build_extend;
 use cairo_lang_sierra::extensions::gas::CostTokenType;
 use cairo_lang_sierra::extensions::range::IntRangeConcreteLibfunc;
-use num_bigint::BigInt;
 
 use super::{CompiledInvocation, CompiledInvocationBuilder, InvocationError};
+use crate::invocations::int::u128_bound;
 use crate::invocations::{
     BuiltinInfo, CostValidationInfo, add_input_variables, get_non_fallthrough_statement_id,
 };
@@ -39,7 +39,7 @@ fn build_try_new(
         let orig_range_check = range_check;
 
         tempvar diff = end - start;
-        const bound = BigInt::from(u128::MAX) + BigInt::from(1);
+        const bound = u128_bound().clone();
         tempvar is_valid_range;
         hint TestLessThan {lhs: diff, rhs: bound} into {dst: is_valid_range};
         jump Valid if is_valid_range != 0;

crates/cairo-lang-sierra-to-casm/src/invocations/range_reduction.rs

@@ -1,5 +1,3 @@
-use std::ops::Shl;
-
 use cairo_lang_casm::builder::CasmBuilder;
 use cairo_lang_casm::casm_build_extend;
 use cairo_lang_sierra::extensions::gas::CostTokenType;
@@ -11,6 +9,7 @@ use super::{
     CompiledInvocation, CompiledInvocationBuilder, InvocationError,
     get_non_fallthrough_statement_id,
 };
+use crate::invocations::int::u128_bound;
 use crate::invocations::misc::validate_under_limit;
 use crate::invocations::{BuiltinInfo, CostValidationInfo, add_input_variables};
 
@@ -89,7 +88,7 @@ pub fn build_felt252_range_reduction(
         maybe_tempvar rc_val = value + minus_range_lower;
         assert rc_val = *(range_check++);
     }
-    let rc_size = BigInt::from(1).shl(128);
+    let rc_size = u128_bound().clone();
     // If the out range is exactly `rc_size` the previous addition to the buffer validated this
     // case as well.
     if out_range.size() < rc_size {