refactor: Simplified EcState native representation to a plain EcPoint. (#1633)

Previously, EcState stored 4 felts (current state + a random point) to
work around EC-OP builtin edge cases in CASM. Since native execution does
direct EC arithmetic with no such constraints, the random point is
unnecessary. EcState is now 2 felts (x, y) with (0, 0) as the infinity
sentinel, matching the semantics of EcPoint::zero().

Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: orizi

Cargo.lock

@@ -74,7 +74,6 @@ num-traits = "0.2"
 p256 = "0.13.2"
 pretty_assertions_sorted = "1.2.3"
 proptest = "1.5.0"
-rand = "0.9.0"
 rayon = "1.10.0"
 rstest = "0.24.0"
 scarb-metadata = "1.12.0"
@@ -184,7 +183,6 @@ keccak.workspace = true
 sha2.workspace = true
 
 # Runtime library dependencies.
-rand.workspace = true
 starknet-curve.workspace = true
 lambdaworks-math.workspace = true
 

Cargo.toml

@@ -152,12 +152,9 @@ fn jitvalue_to_felt(value: &Value) -> Vec<Felt> {
         Value::Sint64(x) => vec![(*x).into()],
         Value::Sint128(x) => vec![(*x).into()],
         Value::Bytes31(bytes) => vec![Felt::from_bytes_le_slice(bytes)],
-        Value::EcPoint(x, y) => {
+        Value::EcPoint(x, y) | Value::EcState(x, y) => {
             vec![*x, *y]
         }
-        Value::EcState(a, b, c, d) => {
-            vec![*a, *b, *c, *d]
-        }
         Value::QM31(a, b, c, d) => vec![
             Felt::from(*a),
             Felt::from(*b),
@@ -551,13 +548,8 @@ mod tests {
     #[test]
     fn test_jitvalue_to_felt_ec_state() {
         assert_eq!(
-            jitvalue_to_felt(&Value::EcState(
-                Felt::ONE,
-                Felt::TWO,
-                Felt::THREE,
-                Felt::from(4)
-            )),
-            vec![Felt::ONE, Felt::TWO, Felt::THREE, Felt::from(4)]
+            jitvalue_to_felt(&Value::EcState(Felt::ONE, Felt::TWO,)),
+            vec![Felt::ONE, Felt::TWO,]
         );
     }
 

binaries/cairo-native-bin-utils/src/lib.rs

@@ -31,7 +31,6 @@ num-integer.workspace = true
 num-bigint.workspace = true
 num-traits.workspace = true
 p256.workspace = true
-rand.workspace = true
 sec1 = { workspace = true, features = ["std"] }
 serde = { workspace = true, features = ["derive"] }
 serde_json.workspace = true

debug_utils/sierra-emu/Cargo.toml

@@ -55,10 +55,8 @@ pub enum Value {
         y: Felt,
     },
     EcState {
-        x0: Felt,
-        y0: Felt,
-        x1: Felt,
-        y1: Felt,
+        x: Felt,
+        y: Felt,
     },
     I128(i128),
     I64(i64),

debug_utils/sierra-emu/src/value.rs

@@ -9,7 +9,6 @@ use cairo_lang_sierra::{
     program_registry::ProgramRegistry,
 };
 use num_traits::identities::Zero;
-use rand::Rng;
 use smallvec::smallvec;
 use starknet_crypto::Felt;
 use starknet_curve::curve_params::BETA;
@@ -113,15 +112,11 @@ fn eval_state_init(
     _info: &SignatureOnlyConcreteLibfunc,
     _args: Vec<Value>,
 ) -> EvalAction {
-    let state = random_ec_point();
-
     EvalAction::NormalBranch(
         0,
         smallvec![Value::EcState {
-            x0: state.x(),
-            y0: state.y(),
-            x1: state.x(),
-            y1: state.y(),
+            x: 0.into(),
+            y: 0.into()
         }],
     )
 }
@@ -131,84 +126,65 @@ fn eval_state_add(
     _info: &SignatureOnlyConcreteLibfunc,
     args: Vec<Value>,
 ) -> EvalAction {
-    let [Value::EcState { x0, y0, x1, y1 }, Value::EcPoint { x, y }]: [Value; 2] =
+    let [Value::EcState { x: s_x, y: s_y }, Value::EcPoint { x, y }]: [Value; 2] =
         args.try_into().unwrap()
     else {
         panic!()
     };
 
-    let mut state = ProjectivePoint::from_affine(x0, y0).unwrap();
+    if s_x.is_zero() && s_y.is_zero() {
+        return EvalAction::NormalBranch(0, smallvec![Value::EcState { x, y }]);
+    }
+    let mut state = ProjectivePoint::from_affine(s_x, s_y).unwrap();
     let point = AffinePoint::new(x, y).unwrap();
 
     state += &point;
-    let state = state.to_affine().unwrap();
-
-    EvalAction::NormalBranch(
-        0,
-        smallvec![Value::EcState {
-            x0: state.x(),
-            y0: state.y(),
-            x1,
-            y1
-        }],
-    )
+    let (x, y) = match state.to_affine() {
+        Ok(state) => (state.x(), state.y()),
+        Err(_) => (Felt::ZERO, Felt::ZERO),
+    };
+    EvalAction::NormalBranch(0, smallvec![Value::EcState { x, y }])
 }
 
 fn eval_state_add_mul(
     _registry: &ProgramRegistry<CoreType, CoreLibfunc>,
     _info: &SignatureOnlyConcreteLibfunc,
     args: Vec<Value>,
 ) -> EvalAction {
-    let [ec @ Value::Unit, Value::EcState { x0, y0, x1, y1 }, Value::Felt(scalar), Value::EcPoint { x, y }]: [Value; 4] =
+    let [ec @ Value::Unit, Value::EcState { x: s_x, y: s_y }, Value::Felt(scalar), Value::EcPoint { x, y }]: [Value; 4] =
         args.try_into().unwrap()
     else {
         panic!()
     };
 
-    let mut state = ProjectivePoint::from_affine(x0, y0).unwrap();
+    let mut state = if s_x.is_zero() && s_y.is_zero() {
+        ProjectivePoint::identity()
+    } else {
+        ProjectivePoint::from_affine(s_x, s_y).unwrap()
+    };
     let point = ProjectivePoint::from_affine(x, y).unwrap();
 
     state += &point.mul(scalar);
-    let state = state.to_affine().unwrap();
-
-    EvalAction::NormalBranch(
-        0,
-        smallvec![
-            ec,
-            Value::EcState {
-                x0: state.x(),
-                y0: state.y(),
-                x1,
-                y1
-            }
-        ],
-    )
+    let (x, y) = match state.to_affine() {
+        Ok(state) => (state.x(), state.y()),
+        Err(_) => (Felt::ZERO, Felt::ZERO),
+    };
+    EvalAction::NormalBranch(0, smallvec![ec, Value::EcState { x, y }])
 }
 
 fn eval_state_finalize(
     _registry: &ProgramRegistry<CoreType, CoreLibfunc>,
     _info: &SignatureOnlyConcreteLibfunc,
     args: Vec<Value>,
 ) -> EvalAction {
-    let [Value::EcState { x0, y0, x1, y1 }]: [Value; 1] = args.try_into().unwrap() else {
+    let [Value::EcState { x, y }]: [Value; 1] = args.try_into().unwrap() else {
         panic!()
     };
 
-    let state = ProjectivePoint::from_affine(x0, y0).unwrap();
-    let random_point = ProjectivePoint::from_affine(x1, y1).unwrap();
-
-    if state.x() == random_point.x() && state.y() == random_point.y() {
+    if x.is_zero() && y.is_zero() {
         EvalAction::NormalBranch(1, smallvec![])
     } else {
-        let point = &state - &random_point;
-        let point = point.to_affine().unwrap();
-        EvalAction::NormalBranch(
-            0,
-            smallvec![Value::EcPoint {
-                x: point.x(),
-                y: point.y(),
-            }],
-        )
+        EvalAction::NormalBranch(0, smallvec![Value::EcPoint { x, y }])
     }
 }
 
@@ -244,22 +220,6 @@ fn eval_point_from_x(
     }
 }
 
-fn random_ec_point() -> AffinePoint {
-    // https://github.com/starkware-libs/cairo/blob/aaad921bba52e729dc24ece07fab2edf09ccfa15/crates/cairo-lang-runner/src/casm_run/mod.rs#L1802
-    let mut rng = rand::rng();
-    let (random_x, random_y) = loop {
-        // Randominzing 31 bytes to make sure is in range.
-        let x_bytes: [u8; 31] = rng.random();
-        let random_x = Felt::from_bytes_be_slice(&x_bytes);
-        let random_y_squared = random_x * random_x * random_x + random_x + BETA;
-        if let Some(random_y) = random_y_squared.sqrt() {
-            break (random_x, random_y);
-        }
-    };
-
-    AffinePoint::new(random_x, random_y).unwrap()
-}
-
 fn eval_zero(
     _registry: &ProgramRegistry<CoreType, CoreLibfunc>,
     _info: &SignatureOnlyConcreteLibfunc,

debug_utils/sierra-emu/src/vm/ec.rs

@@ -29,12 +29,9 @@ pub fn value_to_felt(value: &Value) -> Vec<Felt> {
             felts.push(modulus.into());
             felts
         }
-        Value::EcPoint { x, y } => {
+        Value::EcPoint { x, y } | Value::EcState { x, y } => {
             vec![*x, *y]
         }
-        Value::EcState { x0, y0, x1, y1 } => {
-            vec![*x0, *y0, *x1, *y1]
-        }
         Value::Enum {
             self_ty,
             index,

debug_utils/sierra-emu/tests/common/mod.rs

@@ -112,11 +112,9 @@ impl AbiArgument for ValueWithInfoWrapper<'_> {
                 x.to_bytes(buffer)?;
                 y.to_bytes(buffer)?;
             }
-            (Value::EcState(x, y, x0, y0), CoreTypeConcrete::EcState(_)) => {
+            (Value::EcState(x, y), CoreTypeConcrete::EcState(_)) => {
                 x.to_bytes(buffer)?;
                 y.to_bytes(buffer)?;
-                x0.to_bytes(buffer)?;
-                y0.to_bytes(buffer)?;
             }
             (Value::QM31(a, b, c, d), CoreTypeConcrete::QM31(_)) => {
                 a.to_bytes(buffer)?;