From d0531002dea366e73d6766bde20636e2bfdeaf81 Mon Sep 17 00:00:00 2001 From: Bohdan Ohorodnii Date: Mon, 11 Nov 2024 14:17:03 +0200 Subject: [PATCH] feat: add support for `Secp256k1` syscall --- .../src/execution/native/syscall_handler.rs | 101 +++++++++++++----- .../execution/syscalls/syscall_tests/secp.rs | 4 + 2 files changed, 79 insertions(+), 26 deletions(-) diff --git a/crates/blockifier/src/execution/native/syscall_handler.rs b/crates/blockifier/src/execution/native/syscall_handler.rs index d1609af880..886fa8e033 100644 --- a/crates/blockifier/src/execution/native/syscall_handler.rs +++ b/crates/blockifier/src/execution/native/syscall_handler.rs @@ -5,7 +5,7 @@ use std::hash::RandomState; use std::sync::Arc; use ark_ec::short_weierstrass::{Affine, Projective, SWCurveConfig}; -use ark_ff::PrimeField; +use ark_ff::{BigInt, PrimeField}; use cairo_native::starknet::{ BlockInfo, ExecutionInfo, @@ -18,8 +18,8 @@ use cairo_native::starknet::{ TxV2Info, U256, }; -use cairo_native::starknet_stub::{big4int_to_u256, u256_to_biguint}; use cairo_vm::vm::runners::cairo_runner::ExecutionResources; +use num_bigint::BigUint; use starknet_api::contract_class::EntryPointType; use starknet_api::core::{ calculate_contract_address, @@ -281,7 +281,7 @@ impl<'state> StarknetSyscallHandler for &mut NativeSyscallHandler<'state> { match syscall_base::get_block_hash_base(self.context, block_number, self.state) { Ok(value) => Ok(value), - Err(e) => Err(self.handle_error(remaining_gas, e.into())), + Err(e) => Err(self.handle_error(remaining_gas, e)), } } @@ -650,46 +650,66 @@ impl<'state> StarknetSyscallHandler for &mut NativeSyscallHandler<'state> { fn secp256k1_new( &mut self, - _x: U256, - _y: U256, - _remaining_gas: &mut u128, + x: U256, + y: U256, + remaining_gas: &mut u128, ) -> SyscallResult> { - todo!("Implement secp256k1_new syscall."); + self.pre_execute_syscall(remaining_gas, self.context.gas_costs().secp256k1_new_gas_cost)?; + + Secp256Point::new(x, y) + .map(|option| option.map(|p| p.into())) + .map_err(|e| self.handle_error(remaining_gas, e)) } fn secp256k1_add( &mut self, - _p0: Secp256k1Point, - _p1: Secp256k1Point, - _remaining_gas: &mut u128, + p0: Secp256k1Point, + p1: Secp256k1Point, + remaining_gas: &mut u128, ) -> SyscallResult { - todo!("Implement secp256k1_add syscall."); + self.pre_execute_syscall(remaining_gas, self.context.gas_costs().secp256k1_add_gas_cost)?; + + Ok(Secp256Point::add(p0.into(), p1.into()).into()) } fn secp256k1_mul( &mut self, - _p: Secp256k1Point, - _m: U256, - _remaining_gas: &mut u128, + p: Secp256k1Point, + m: U256, + remaining_gas: &mut u128, ) -> SyscallResult { - todo!("Implement secp256k1_mul syscall."); + self.pre_execute_syscall(remaining_gas, self.context.gas_costs().secp256k1_mul_gas_cost)?; + + Ok(Secp256Point::mul(p.into(), m).into()) } fn secp256k1_get_point_from_x( &mut self, - _x: U256, - _y_parity: bool, - _remaining_gas: &mut u128, + x: U256, + y_parity: bool, + remaining_gas: &mut u128, ) -> SyscallResult> { - todo!("Implement secp256k1_get_point_from_x syscall."); + self.pre_execute_syscall( + remaining_gas, + self.context.gas_costs().secp256k1_get_point_from_x_gas_cost, + )?; + + Secp256Point::get_point_from_x(x, y_parity) + .map(|option| option.map(|p| p.into())) + .map_err(|e| self.handle_error(remaining_gas, e)) } fn secp256k1_get_xy( &mut self, - _p: Secp256k1Point, - _remaining_gas: &mut u128, + p: Secp256k1Point, + remaining_gas: &mut u128, ) -> SyscallResult<(U256, U256)> { - todo!("Implement secp256k1_get_xy syscall."); + self.pre_execute_syscall( + remaining_gas, + self.context.gas_costs().secp256k1_get_xy_gas_cost, + )?; + + Ok((p.x, p.y)) } fn secp256r1_new( @@ -809,8 +829,8 @@ impl From> for Secp256r1Point { impl From for Secp256Point { fn from(p: Secp256k1Point) -> Self { Secp256Point(Affine { - x: u256_to_biguint(p.x).into(), - y: u256_to_biguint(p.y).into(), + x: u256_to_big4int(p.x).into(), + y: u256_to_big4int(p.y).into(), infinity: p.is_infinity, }) } @@ -819,8 +839,8 @@ impl From for Secp256Point { impl From for Secp256Point { fn from(p: Secp256r1Point) -> Self { Secp256Point(Affine { - x: u256_to_biguint(p.x).into(), - y: u256_to_biguint(p.y).into(), + x: u256_to_big4int(p.x).into(), + y: u256_to_big4int(p.y).into(), infinity: p.is_infinity, }) } @@ -880,6 +900,35 @@ impl fmt::Debug for Secp256Point { } } +fn u256_to_biguint(u256: U256) -> BigUint { + let lo = BigUint::from(u256.lo); + let hi = BigUint::from(u256.hi); + + (hi << 128) + lo +} + +fn big4int_to_u256(b_int: BigInt<4>) -> U256 { + let [a, b, c, d] = b_int.0; + + let lo = u128::from(a) | (u128::from(b) << 64); + let hi = u128::from(c) | (u128::from(d) << 64); + + U256 { lo, hi } +} + +fn u256_to_big4int(u256: U256) -> BigInt<4> { + fn to_u64s(bytes: [u8; 16]) -> (u64, u64) { + let lo_bytes: [u8; 8] = bytes[0..8].try_into().expect("Take high bytes"); + let lo: u64 = u64::from_le_bytes(lo_bytes); + let hi_bytes: [u8; 8] = bytes[8..16].try_into().expect("Take low bytes"); + let hi: u64 = u64::from_le_bytes(hi_bytes); + (lo, hi) + } + let (hi_lo, hi_hi) = to_u64s(u256.hi.to_le_bytes()); + let (lo_lo, lo_hi) = to_u64s(u256.lo.to_le_bytes()); + BigInt::new([lo_lo, lo_hi, hi_lo, hi_hi]) +} + #[cfg(test)] mod test { use cairo_native::starknet::U256; diff --git a/crates/blockifier/src/execution/syscalls/syscall_tests/secp.rs b/crates/blockifier/src/execution/syscalls/syscall_tests/secp.rs index 23e518ae1a..af01610ddf 100644 --- a/crates/blockifier/src/execution/syscalls/syscall_tests/secp.rs +++ b/crates/blockifier/src/execution/syscalls/syscall_tests/secp.rs @@ -9,6 +9,10 @@ use crate::test_utils::contracts::FeatureContract; use crate::test_utils::initial_test_state::test_state; use crate::test_utils::{trivial_external_entry_point_new, CairoVersion, BALANCE}; +#[cfg_attr( + feature = "cairo_native", + test_case(FeatureContract::TestContract(CairoVersion::Native), 17044156; "Native") +)] #[test_case(FeatureContract::TestContract(CairoVersion::Cairo1), 17034156; "VM")] fn test_secp256k1(test_contract: FeatureContract, expected_gas: u64) { let chain_info = &ChainInfo::create_for_testing();