lambdaclass
diff --git a/‎src/libfuncs/circuit.rs‎
Lines changed: 28 additions & 88 deletions b/‎src/libfuncs/circuit.rs‎
Lines changed: 28 additions & 88 deletions
@@ -4,11 +4,12 @@
 
 use super::{increment_builtin_counter_by, LibfuncHelper};
 use crate::{
-    error::{Result, SierraAssertError},
+    error::{panic::ToNativeAssertError, Result, SierraAssertError},
     execution_result::{ADD_MOD_BUILTIN_SIZE, MUL_MOD_BUILTIN_SIZE, RANGE_CHECK96_BUILTIN_SIZE},
     libfuncs::r#struct::build_struct_value,
     metadata::{
-        drop_overrides::DropOverridesMeta, realloc_bindings::ReallocBindingsMeta, MetadataStorage,
+        drop_overrides::DropOverridesMeta, realloc_bindings::ReallocBindingsMeta,
+        runtime_bindings::RuntimeBindingsMeta, MetadataStorage,
     },
     native_panic,
     types::{circuit::build_u384_struct_type, TypeBuilder},
@@ -332,6 +333,7 @@ fn build_eval<'ctx, 'this>(
         entry,
         location,
         helper,
+        metadata,
         circuit_info,
         circuit_data,
         circuit_modulus,
@@ -475,11 +477,13 @@ fn build_eval<'ctx, 'this>(
 ///
 /// The original Cairo hint evaluates all gates, even in case of failure.
 /// This implementation exits on first error, as there is no need for the partial outputs yet.
+#[allow(clippy::too_many_arguments)]
 fn build_gate_evaluation<'ctx, 'this>(
     context: &'this Context,
     mut block: &'this Block<'ctx>,
     location: Location<'ctx>,
     helper: &LibfuncHelper<'ctx, 'this>,
+    metadata: &mut MetadataStorage,
     circuit_info: &circuit::CircuitInfo,
     circuit_data: Value<'ctx, 'ctx>,
     circuit_modulus: Value<'ctx, 'ctx>,
@@ -638,17 +642,34 @@ fn build_gate_evaluation<'ctx, 'this>(
                     let integer_type = rhs_value.r#type();
 
                     // Apply egcd to find gcd and inverse
-                    let egcd_result_block = build_euclidean_algorithm(
+                    let runtime_bindings_meta = metadata
+                        .get_mut::<RuntimeBindingsMeta>()
+                        .to_native_assert_error(
+                            "Unable to get the RuntimeBindingsMeta from MetadataStorage",
+                        )?;
+                    let euclidean_result = runtime_bindings_meta.extended_euclidean_algorithm(
                         context,
+                        helper.module,
                         block,
                         location,
-                        helper,
                         rhs_value,
                         circuit_modulus,
                     )?;
-                    let gcd = egcd_result_block.arg(0)?;
-                    let inverse = egcd_result_block.arg(1)?;
-                    block = egcd_result_block;
+                    // Extract the values from the result struct
+                    let gcd = block.extract_value(
+                        context,
+                        location,
+                        euclidean_result,
+                        integer_type,
+                        0,
+                    )?;
+                    let inverse = block.extract_value(
+                        context,
+                        location,
+                        euclidean_result,
+                        integer_type,
+                        1,
+                    )?;
 
                     // if the gcd is not 1, then fail (a and b are not coprimes)
                     let one = block.const_int_from_type(context, location, 1, integer_type)?;
@@ -1037,87 +1058,6 @@ fn u384_integer_to_struct<'a>(
     )?)
 }
 
-/// The extended euclidean algorithm calculates the greatest common divisor (gcd) of two integers a and b,
-/// as well as the bezout coefficients x and y such that ax+by=gcd(a,b)
-/// if gcd(a,b) = 1, then x is the modular multiplicative inverse of a modulo b.
-/// See https://en.wikipedia.org/wiki/Extended_Euclidean_algorithm
-///
-/// Given two numbers a, b. It returns a block with gcd(a, b) and the bezout coefficient x.
-fn build_euclidean_algorithm<'ctx, 'this>(
-    context: &'ctx Context,
-    block: &'ctx Block<'ctx>,
-    location: Location<'ctx>,
-    helper: &LibfuncHelper<'ctx, 'this>,
-    a: Value<'ctx, 'ctx>,
-    b: Value<'ctx, 'ctx>,
-) -> Result<&'this Block<'ctx>> {
-    let integer_type = a.r#type();
-
-    let loop_block = helper.append_block(Block::new(&[
-        (integer_type, location),
-        (integer_type, location),
-        (integer_type, location),
-        (integer_type, location),
-    ]));
-    let end_block = helper.append_block(Block::new(&[
-        (integer_type, location),
-        (integer_type, location),
-    ]));
-
-    // The algorithm egcd works by calculating a series of remainders, each the remainder of dividing the previous two
-    // For the initial setup, r0 = b, r1 = a
-    // This order is chosen because if we reverse them, then the first iteration will just swap them
-    let prev_remainder = b;
-    let remainder = a;
-    // Similarly we'll calculate another series which starts 0,1,... and from which we will retrieve the modular inverse of a
-    let prev_inverse = block.const_int_from_type(context, location, 0, integer_type)?;
-    let inverse = block.const_int_from_type(context, location, 1, integer_type)?;
-    block.append_operation(cf::br(
-        loop_block,
-        &[prev_remainder, remainder, prev_inverse, inverse],
-        location,
-    ));
-
-    // -- Loop body --
-    // Arguments are rem_(i-1), rem, inv_(i-1), inv
-    let prev_remainder = loop_block.arg(0)?;
-    let remainder = loop_block.arg(1)?;
-    let prev_inverse = loop_block.arg(2)?;
-    let inverse = loop_block.arg(3)?;
-
-    // First calculate q = rem_(i-1)/rem_i, rounded down
-    let quotient =
-        loop_block.append_op_result(arith::divui(prev_remainder, remainder, location))?;
-
-    // Then r_(i+1) = r_(i-1) - q * r_i, and inv_(i+1) = inv_(i-1) - q * inv_i
-    let rem_times_quo = loop_block.muli(remainder, quotient, location)?;
-    let inv_times_quo = loop_block.muli(inverse, quotient, location)?;
-    let next_remainder =
-        loop_block.append_op_result(arith::subi(prev_remainder, rem_times_quo, location))?;
-    let next_inverse =
-        loop_block.append_op_result(arith::subi(prev_inverse, inv_times_quo, location))?;
-
-    // Check if r_(i+1) is 0
-    // If true, then:
-    // - r_i is the gcd of a and b
-    // - inv_i is the bezout coefficient x
-
-    let zero = loop_block.const_int_from_type(context, location, 0, integer_type)?;
-    let next_remainder_eq_zero =
-        loop_block.cmpi(context, CmpiPredicate::Eq, next_remainder, zero, location)?;
-    loop_block.append_operation(cf::cond_br(
-        context,
-        next_remainder_eq_zero,
-        end_block,
-        loop_block,
-        &[remainder, inverse],
-        &[remainder, next_remainder, inverse, next_inverse],
-        location,
-    ));
-
-    Ok(end_block)
-}
-
 /// Extracts values from indexes `from` - `to` (exclusive) and builds a new value of type `result_type`
 ///
 /// Can be used with arrays, or structs with multiple elements of a single type.