fix StubSyscallHandler secp ops returning identity element

The secp256k1_add / secp256k1_mul / secp256r1_add / secp256r1_mul stub
implementations called `p.to_encoded_point(false)` and then assumed the
result was Coordinates::Uncompressed. The identity element returns
Coordinates::Identity instead, so P + (-P) and k * P (mod ord) panicked
with unreachable!().

Pre-existing bug in sierra-emu, surfaced more visibly by the trait
alignment in this PR (which added is_infinity to the surface).

Add an explicit Coordinates::Identity arm to all four sites, returning
the canonical (0, 0) + is_infinity: true point.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: avi-starkware

debug_utils/sierra-emu/src/starknet.rs

@@ -39,7 +39,10 @@ pub trait StarknetSyscallHandler {
 
     fn get_execution_info_v2(&mut self, remaining_gas: &mut u64) -> SyscallResult<ExecutionInfoV2>;
 
-    fn get_execution_info_v3(&mut self, _remaining_gas: &mut u64) -> SyscallResult<ExecutionInfoV3> {
+    fn get_execution_info_v3(
+        &mut self,
+        _remaining_gas: &mut u64,
+    ) -> SyscallResult<ExecutionInfoV3> {
         unimplemented!()
     }
 
@@ -500,9 +503,17 @@ impl StarknetSyscallHandler for StubSyscallHandler {
         let p = p.to_encoded_point(false);
         let (x, y) = match p.coordinates() {
             Coordinates::Uncompressed { x, y } => (x, y),
+            Coordinates::Identity => {
+                // P + (-P) yields the identity. Return the canonical (0, 0) +
+                // is_infinity encoding (see Secp256k1Point::into_value).
+                return Ok(Secp256k1Point {
+                    x: U256 { lo: 0, hi: 0 },
+                    y: U256 { lo: 0, hi: 0 },
+                    is_infinity: true,
+                });
+            }
             _ => {
-                // This should be unreachable because we explicitly asked for the uncompressed
-                // encoding.
+                // We explicitly asked for the uncompressed encoding.
                 unreachable!()
             }
         };
@@ -565,9 +576,16 @@ impl StarknetSyscallHandler for StubSyscallHandler {
         let p = p.to_encoded_point(false);
         let (x, y) = match p.coordinates() {
             Coordinates::Uncompressed { x, y } => (x, y),
+            Coordinates::Identity => {
+                // m * P can be the identity (e.g. m = ord(P)).
+                return Ok(Secp256k1Point {
+                    x: U256 { lo: 0, hi: 0 },
+                    y: U256 { lo: 0, hi: 0 },
+                    is_infinity: true,
+                });
+            }
             _ => {
-                // This should be unreachable because we explicitly asked for the uncompressed
-                // encoding.
+                // We explicitly asked for the uncompressed encoding.
                 unreachable!()
             }
         };
@@ -737,9 +755,17 @@ impl StarknetSyscallHandler for StubSyscallHandler {
         let p = p.to_encoded_point(false);
         let (x, y) = match p.coordinates() {
             Coordinates::Uncompressed { x, y } => (x, y),
+            Coordinates::Identity => {
+                // P + (-P) yields the identity. Return the canonical (0, 0) +
+                // is_infinity encoding (see Secp256r1Point::into_value).
+                return Ok(Secp256r1Point {
+                    x: U256 { lo: 0, hi: 0 },
+                    y: U256 { lo: 0, hi: 0 },
+                    is_infinity: true,
+                });
+            }
             _ => {
-                // This should be unreachable because we explicitly asked for the uncompressed
-                // encoding.
+                // We explicitly asked for the uncompressed encoding.
                 unreachable!()
             }
         };
@@ -801,9 +827,16 @@ impl StarknetSyscallHandler for StubSyscallHandler {
         let p = p.to_encoded_point(false);
         let (x, y) = match p.coordinates() {
             Coordinates::Uncompressed { x, y } => (x, y),
+            Coordinates::Identity => {
+                // m * P can be the identity (e.g. m = ord(P)).
+                return Ok(Secp256r1Point {
+                    x: U256 { lo: 0, hi: 0 },
+                    y: U256 { lo: 0, hi: 0 },
+                    is_infinity: true,
+                });
+            }
             _ => {
-                // This should be unreachable because we explicitly asked for the uncompressed
-                // encoding.
+                // We explicitly asked for the uncompressed encoding.
                 unreachable!()
             }
         };

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

@@ -655,8 +655,7 @@ fn eval_call_contract(
         }
     };
 
-    let result =
-        syscall_handler.call_contract(address, entry_point_selector, &calldata, &mut gas);
+    let result = syscall_handler.call_contract(address, entry_point_selector, &calldata, &mut gas);
 
     match result {
         Ok(return_values) => EvalAction::NormalBranch(