From e9534a41b560d9687d982e7a81e9b3a8eb96e304 Mon Sep 17 00:00:00 2001 From: Federica Date: Wed, 22 Feb 2023 15:42:29 -0300 Subject: [PATCH 01/38] Add cache to keccak builtin --- src/vm/runners/builtin_runner/keccak.rs | 29 +++++++++++++++---------- 1 file changed, 17 insertions(+), 12 deletions(-) diff --git a/src/vm/runners/builtin_runner/keccak.rs b/src/vm/runners/builtin_runner/keccak.rs index 96f4fab64c..ad5a0b396b 100644 --- a/src/vm/runners/builtin_runner/keccak.rs +++ b/src/vm/runners/builtin_runner/keccak.rs @@ -1,3 +1,7 @@ +use std::cell::RefCell; +use std::collections::HashMap; +use std::rc::Rc; + use crate::hint_processor::builtin_hint_processor::keccak_utils::left_pad_u64; use crate::math_utils::safe_div_usize; use crate::types::instance_definitions::keccak_instance_def::KeccakInstanceDef; @@ -21,11 +25,11 @@ pub struct KeccakBuiltinRunner { pub base: usize, pub(crate) cells_per_instance: u32, pub(crate) n_input_cells: u32, - verified_addresses: Vec, pub(crate) stop_ptr: Option, pub(crate) included: bool, state_rep: Vec, instances_per_component: u32, + cache: Rc>>, } impl KeccakBuiltinRunner { @@ -36,10 +40,10 @@ impl KeccakBuiltinRunner { n_input_cells: instance_def._state_rep.len() as u32, cells_per_instance: instance_def.cells_per_builtin(), stop_ptr: None, - verified_addresses: Vec::new(), included, instances_per_component: instance_def._instance_per_component, state_rep: instance_def._state_rep.clone(), + cache: Rc::new(RefCell::new(HashMap::new())), } } @@ -74,15 +78,14 @@ impl KeccakBuiltinRunner { if index < self.n_input_cells as usize { return Ok(None); } + if let Some(felt) = self.cache.borrow().get(&address) { + return Ok(Some(felt.into())); + } let first_input_addr = address .sub_usize(index) .map_err(|_| RunnerError::KeccakNoFirstInput)?; - if self.verified_addresses.contains(&first_input_addr) { - return Ok(None); - } - let mut input_felts_u64 = vec![]; for i in 0..self.n_input_cells { @@ -119,9 +122,13 @@ impl KeccakBuiltinRunner { keccak::f1600(&mut input_felts_u64); - return Ok(input_felts_u64 - .get(address.offset - 1) - .map(|x| Felt::from(*x).into())); + for (i, val) in input_felts_u64.iter().enumerate() { + self.cache + .borrow_mut() + .insert(first_input_addr + i, Felt::from(*val as i64)); + } + + return Ok(self.cache.borrow().get(&address).map(|x| x.into())); } Ok(None) } @@ -587,9 +594,7 @@ mod tests { ((0, 35), 0) ]; - let mut builtin = KeccakBuiltinRunner::new(&KeccakInstanceDef::default(), true); - - builtin.verified_addresses.push(Relocatable::from((0, 16))); + let builtin = KeccakBuiltinRunner::new(&KeccakInstanceDef::default(), true); let result = builtin.deduce_memory_cell(Relocatable::from((0, 25)), &memory); assert_eq!(result, Ok(None)); From 9844eee4fdf3e8e3caa5ef7c6e1a901ae232429b Mon Sep 17 00:00:00 2001 From: Federica Date: Thu, 2 Mar 2023 18:54:32 -0300 Subject: [PATCH 02/38] Temporaryly unhide recursive layout for debugging --- src/main.rs | 2 +- src/vm/runners/cairo_runner.rs | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/src/main.rs b/src/main.rs index 363dc933aa..321293dc3a 100644 --- a/src/main.rs +++ b/src/main.rs @@ -38,7 +38,7 @@ struct Args { fn validate_layout(value: &str) -> Result<(), String> { match value { - "plain" | "small" | "dex" | "bitwise" | "perpetual_with_bitwise" | "all" => Ok(()), + "plain" | "small" | "dex" | "bitwise" | "perpetual_with_bitwise" | "all" | "recursive" => Ok(()), _ => Err(format!("{value} is not a valid layout")), } } diff --git a/src/vm/runners/cairo_runner.rs b/src/vm/runners/cairo_runner.rs index 5c3f25dca4..2297b57280 100644 --- a/src/vm/runners/cairo_runner.rs +++ b/src/vm/runners/cairo_runner.rs @@ -102,6 +102,7 @@ impl CairoRunner { "perpetual_with_bitwise" => CairoLayout::perpetual_with_bitwise_instance(), "bitwise" => CairoLayout::bitwise_instance(), "all" => CairoLayout::all_instance(), + "recursive" => CairoLayout::recursive_instance(), name => return Err(RunnerError::InvalidLayoutName(name.to_string())), }; Ok(CairoRunner { From 5cf85887f7ca6038f3e8366da834641517c7047f Mon Sep 17 00:00:00 2001 From: Federica Date: Thu, 2 Mar 2023 19:10:09 -0300 Subject: [PATCH 03/38] Use same keccak method as the one used in keccak_utils --- .../builtin_hint_processor/keccak_utils.rs | 7 ----- src/main.rs | 4 ++- src/vm/runners/builtin_runner/keccak.rs | 26 ++++++++++--------- 3 files changed, 17 insertions(+), 20 deletions(-) diff --git a/src/hint_processor/builtin_hint_processor/keccak_utils.rs b/src/hint_processor/builtin_hint_processor/keccak_utils.rs index f6bbfee3a6..f823497607 100644 --- a/src/hint_processor/builtin_hint_processor/keccak_utils.rs +++ b/src/hint_processor/builtin_hint_processor/keccak_utils.rs @@ -180,10 +180,3 @@ fn left_pad(bytes_vector: &mut [u8], n_zeros: usize) -> Vec { res } - -pub(crate) fn left_pad_u64(bytes_vector: &mut [u64], n_zeros: usize) -> Vec { - let mut res: Vec = vec![0; n_zeros]; - res.extend(bytes_vector.iter()); - - res -} diff --git a/src/main.rs b/src/main.rs index 321293dc3a..614d7586f2 100644 --- a/src/main.rs +++ b/src/main.rs @@ -38,7 +38,9 @@ struct Args { fn validate_layout(value: &str) -> Result<(), String> { match value { - "plain" | "small" | "dex" | "bitwise" | "perpetual_with_bitwise" | "all" | "recursive" => Ok(()), + "plain" | "small" | "dex" | "bitwise" | "perpetual_with_bitwise" | "all" | "recursive" => { + Ok(()) + } _ => Err(format!("{value} is not a valid layout")), } } diff --git a/src/vm/runners/builtin_runner/keccak.rs b/src/vm/runners/builtin_runner/keccak.rs index ba1cf221cd..56cf559559 100644 --- a/src/vm/runners/builtin_runner/keccak.rs +++ b/src/vm/runners/builtin_runner/keccak.rs @@ -2,7 +2,6 @@ use std::cell::RefCell; use std::collections::HashMap; use std::rc::Rc; -use crate::hint_processor::builtin_hint_processor::keccak_utils::left_pad_u64; use crate::math_utils::safe_div_usize; use crate::types::instance_definitions::keccak_instance_def::KeccakInstanceDef; use crate::types::relocatable::{MaybeRelocatable, Relocatable}; @@ -14,11 +13,11 @@ use crate::vm::vm_memory::memory_segments::MemorySegmentManager; use felt::Felt; use num_integer::div_ceil; use num_traits::{One, ToPrimitive}; +use sha2::Digest; +use sha3::Keccak256; use super::KECCAK_BUILTIN_NAME; -const KECCAK_ARRAY_LEN: usize = 25; - #[derive(Debug, Clone)] pub struct KeccakBuiltinRunner { ratio: u32, @@ -111,17 +110,20 @@ impl KeccakBuiltinRunner { )); } - let len = input_felts_u64.len(); - let mut input_felts_u64 = left_pad_u64(&mut input_felts_u64, KECCAK_ARRAY_LEN - len) - .try_into() - .map_err(|_| RunnerError::SliceToArrayError)?; - - keccak::f1600(&mut input_felts_u64); - - for (i, val) in input_felts_u64.iter().enumerate() { + let keccak_input: Vec = input_felts_u64 + .iter() + .flat_map(|x| x.to_be_bytes()) + .collect(); + let mut hasher = Keccak256::new(); + hasher.update(keccak_input); + let hashed = hasher.finalize(); + + for (i, felt_start) in (0..hashed.len() / 8).enumerate() { + let felt_end = felt_start + 8; + let val = u64::from_be_bytes(hashed[felt_start..felt_end].try_into().unwrap()); self.cache .borrow_mut() - .insert(first_input_addr + i, Felt::from(*val as i64)); + .insert(first_input_addr + i, Felt::from(val)); } return Ok(self.cache.borrow().get(&address).map(|x| x.into())); From 601c7ecccbdb05c5fcea087925e50584bc521d10 Mon Sep 17 00:00:00 2001 From: Federica Date: Fri, 3 Mar 2023 15:44:46 -0300 Subject: [PATCH 04/38] Make keccak builtin work --- .../builtin_hint_processor/keccak_utils.rs | 2 +- src/vm/runners/builtin_runner/keccak.rs | 89 ++++++++++++------- 2 files changed, 60 insertions(+), 31 deletions(-) diff --git a/src/hint_processor/builtin_hint_processor/keccak_utils.rs b/src/hint_processor/builtin_hint_processor/keccak_utils.rs index f823497607..a979506f5a 100644 --- a/src/hint_processor/builtin_hint_processor/keccak_utils.rs +++ b/src/hint_processor/builtin_hint_processor/keccak_utils.rs @@ -174,7 +174,7 @@ pub fn unsafe_keccak_finalize( Ok(()) } -fn left_pad(bytes_vector: &mut [u8], n_zeros: usize) -> Vec { +pub(crate) fn left_pad(bytes_vector: &mut [u8], n_zeros: usize) -> Vec { let mut res: Vec = vec![0; n_zeros]; res.extend(bytes_vector.iter()); diff --git a/src/vm/runners/builtin_runner/keccak.rs b/src/vm/runners/builtin_runner/keccak.rs index 56cf559559..c7c33c78ce 100644 --- a/src/vm/runners/builtin_runner/keccak.rs +++ b/src/vm/runners/builtin_runner/keccak.rs @@ -11,13 +11,14 @@ use crate::vm::vm_core::VirtualMachine; use crate::vm::vm_memory::memory::Memory; use crate::vm::vm_memory::memory_segments::MemorySegmentManager; use felt::Felt; +use num_bigint::BigUint; use num_integer::div_ceil; use num_traits::{One, ToPrimitive}; -use sha2::Digest; -use sha3::Keccak256; use super::KECCAK_BUILTIN_NAME; +const KECCAK_FELT_BYTE_SIZE: usize = 25; // 200 / 8 + #[derive(Debug, Clone)] pub struct KeccakBuiltinRunner { ratio: u32, @@ -100,35 +101,56 @@ impl KeccakBuiltinRunner { input_felts_u64.push(val) } - if let Some((i, bits)) = self.state_rep.iter().enumerate().next() { - let val = memory.get_integer(first_input_addr + i)?; - if val.as_ref() >= &(Felt::one() << *bits) { - return Err(RunnerError::IntegerBiggerThanPowerOfTwo( - (first_input_addr + i).into(), - *bits, - val.into_owned(), - )); - } - - let keccak_input: Vec = input_felts_u64 - .iter() - .flat_map(|x| x.to_be_bytes()) - .collect(); - let mut hasher = Keccak256::new(); - hasher.update(keccak_input); - let hashed = hasher.finalize(); - - for (i, felt_start) in (0..hashed.len() / 8).enumerate() { - let felt_end = felt_start + 8; - let val = u64::from_be_bytes(hashed[felt_start..felt_end].try_into().unwrap()); - self.cache - .borrow_mut() - .insert(first_input_addr + i, Felt::from(val)); - } - - return Ok(self.cache.borrow().get(&address).map(|x| x.into())); + // if let Some((i, bits)) = self.state_rep.iter().enumerate().next() { + // let val = memory.get_integer(first_input_addr + i)?; + // if val.as_ref() >= &(Felt::one() << *bits) { + // return Err(RunnerError::IntegerBiggerThanPowerOfTwo( + // (first_input_addr + i).into(), + // *bits, + // val.into_owned(), + // )); + // } + // } + + let input_message: Vec = input_felts_u64 + .iter() + .flat_map(|x| Self::right_pad(&mut x.to_le_bytes(), KECCAK_FELT_BYTE_SIZE)) + .collect(); + // keccak_f start: + let bigint = BigUint::from_bytes_le(&input_message); + let mut keccak_input = vec![]; + let w = 64; + for i in 0..25 + /* u**2 */ + { + keccak_input.push( + ((&bigint >> (i * w)) & (BigUint::from(2_u8).pow(w) - BigUint::one())) + .to_u64() + .ok_or(RunnerError::KeccakInputCellsNotU64)?, + ) + } + // This unwrap wont fail as the vec is 25 elements long // use from_fn here + let mut keccak_input: [u64; 25] = keccak_input.try_into().unwrap(); + keccak::f1600(&mut keccak_input); + let keccak_result = keccak_input + .iter() + .enumerate() + .map(|(i, x)| BigUint::from(*x) << (i * w as usize)) + .sum::() + .to_bytes_le(); + // keccak_f end + let mut start_index = 0_usize; + for (i, bits) in self.state_rep.iter().enumerate() { + let end_index = start_index + *bits as usize / 8; + self.cache.borrow_mut().insert( + first_input_addr + i, + Felt::from(BigUint::from_bytes_le( + &keccak_result[start_index..end_index], + )), + ); + start_index = end_index; } - Ok(None) + Ok(self.cache.borrow().get(&address).map(|x| x.into())) } pub fn get_allocated_memory_units(&self, vm: &VirtualMachine) -> Result { @@ -254,6 +276,13 @@ impl KeccakBuiltinRunner { // So the real number is 4 * 64 * 1024 = 262144. safe_div_usize(262144_usize, diluted_n_bits as usize).unwrap_or(0) } + + fn right_pad(bytes: &[u8], final_size: usize) -> Vec { + let zeros: Vec = vec![0; final_size - bytes.len()]; + let mut bytes_vector = bytes.to_vec(); + bytes_vector.extend(zeros); + bytes_vector + } } #[cfg(test)] From 9b76e5f64b69aef4eb95519dd241f7ece7985677 Mon Sep 17 00:00:00 2001 From: Federica Date: Fri, 3 Mar 2023 15:45:30 -0300 Subject: [PATCH 05/38] Fix visisbility --- src/hint_processor/builtin_hint_processor/keccak_utils.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/hint_processor/builtin_hint_processor/keccak_utils.rs b/src/hint_processor/builtin_hint_processor/keccak_utils.rs index a979506f5a..f823497607 100644 --- a/src/hint_processor/builtin_hint_processor/keccak_utils.rs +++ b/src/hint_processor/builtin_hint_processor/keccak_utils.rs @@ -174,7 +174,7 @@ pub fn unsafe_keccak_finalize( Ok(()) } -pub(crate) fn left_pad(bytes_vector: &mut [u8], n_zeros: usize) -> Vec { +fn left_pad(bytes_vector: &mut [u8], n_zeros: usize) -> Vec { let mut res: Vec = vec![0; n_zeros]; res.extend(bytes_vector.iter()); From 86249fc4764e0b28e46cc23481bddd5e7c562684 Mon Sep 17 00:00:00 2001 From: Federica Date: Fri, 3 Mar 2023 16:57:30 -0300 Subject: [PATCH 06/38] Small refactor --- src/vm/errors/runner_errors.rs | 6 ++-- src/vm/runners/builtin_runner/keccak.rs | 40 +++++++++++-------------- 2 files changed, 22 insertions(+), 24 deletions(-) diff --git a/src/vm/errors/runner_errors.rs b/src/vm/errors/runner_errors.rs index 730e30f464..6abfe8800b 100644 --- a/src/vm/errors/runner_errors.rs +++ b/src/vm/errors/runner_errors.rs @@ -1,7 +1,7 @@ use std::collections::HashSet; use super::memory_errors::MemoryError; -use crate::types::relocatable::{MaybeRelocatable, Relocatable}; +use crate::types::relocatable::Relocatable; use felt::Felt; use thiserror::Error; @@ -32,7 +32,7 @@ pub enum RunnerError { #[error("Given builtins are not in appropiate order")] DisorderedBuiltins, #[error("Expected integer at address {0:?} to be smaller than 2^{1}, Got {2}")] - IntegerBiggerThanPowerOfTwo(MaybeRelocatable, u32, Felt), + IntegerBiggerThanPowerOfTwo(Relocatable, u32, Felt), #[error("{0}")] EcOpSameXCoordinate(String), #[error("EcOpBuiltin: point {0:?} is not on the curve")] @@ -79,6 +79,8 @@ pub enum RunnerError { Memory(#[from] MemoryError), #[error("keccak_builtin: Failed to get first input address")] KeccakNoFirstInput, + #[error("keccak_builtin: Expected integer at address {0}")] + KeccakExpectedInteger(Relocatable), #[error("keccak_builtin: Failed to convert input cells to u64 values")] KeccakInputCellsNotU64, } diff --git a/src/vm/runners/builtin_runner/keccak.rs b/src/vm/runners/builtin_runner/keccak.rs index c7c33c78ce..31d4d1e580 100644 --- a/src/vm/runners/builtin_runner/keccak.rs +++ b/src/vm/runners/builtin_runner/keccak.rs @@ -88,41 +88,36 @@ impl KeccakBuiltinRunner { let mut input_felts_u64 = vec![]; - for i in 0..self.n_input_cells { - let val = match memory.get(&(first_input_addr + i as usize)) { - Some(val) => val - .as_ref() - .get_int_ref() - .and_then(|x| x.to_u64()) - .ok_or(RunnerError::KeccakInputCellsNotU64)?, + for i in 0..self.n_input_cells as usize { + let val = match memory.get(&(first_input_addr + i)) { + Some(value) => { + let num = value + .get_int_ref() + .ok_or(RunnerError::KeccakExpectedInteger(first_input_addr + i))?; + if num >= &(Felt::one() << self.state_rep[i]) { + return Err(RunnerError::IntegerBiggerThanPowerOfTwo( + first_input_addr + i, + self.state_rep[i], + num.clone(), + )); + } + num.clone() + } _ => return Ok(None), }; input_felts_u64.push(val) } - // if let Some((i, bits)) = self.state_rep.iter().enumerate().next() { - // let val = memory.get_integer(first_input_addr + i)?; - // if val.as_ref() >= &(Felt::one() << *bits) { - // return Err(RunnerError::IntegerBiggerThanPowerOfTwo( - // (first_input_addr + i).into(), - // *bits, - // val.into_owned(), - // )); - // } - // } - let input_message: Vec = input_felts_u64 .iter() - .flat_map(|x| Self::right_pad(&mut x.to_le_bytes(), KECCAK_FELT_BYTE_SIZE)) + .flat_map(|x| Self::right_pad(&mut x.to_biguint().to_bytes_le(), KECCAK_FELT_BYTE_SIZE)) .collect(); // keccak_f start: let bigint = BigUint::from_bytes_le(&input_message); let mut keccak_input = vec![]; let w = 64; - for i in 0..25 - /* u**2 */ - { + for i in 0..25 { keccak_input.push( ((&bigint >> (i * w)) & (BigUint::from(2_u8).pow(w) - BigUint::one())) .to_u64() @@ -150,6 +145,7 @@ impl KeccakBuiltinRunner { ); start_index = end_index; } + dbg!(&self.cache); Ok(self.cache.borrow().get(&address).map(|x| x.into())) } From 916f6991ed4bac3094acfafdd924ec9a2925db1c Mon Sep 17 00:00:00 2001 From: Federica Date: Fri, 3 Mar 2023 17:03:25 -0300 Subject: [PATCH 07/38] Refactor --- src/vm/runners/builtin_runner/keccak.rs | 53 +++++++++++++------------ 1 file changed, 28 insertions(+), 25 deletions(-) diff --git a/src/vm/runners/builtin_runner/keccak.rs b/src/vm/runners/builtin_runner/keccak.rs index 31d4d1e580..4f6e5402bc 100644 --- a/src/vm/runners/builtin_runner/keccak.rs +++ b/src/vm/runners/builtin_runner/keccak.rs @@ -86,7 +86,7 @@ impl KeccakBuiltinRunner { .sub_usize(index) .map_err(|_| RunnerError::KeccakNoFirstInput)?; - let mut input_felts_u64 = vec![]; + let mut input_felts = vec![]; for i in 0..self.n_input_cells as usize { let val = match memory.get(&(first_input_addr + i)) { @@ -106,34 +106,15 @@ impl KeccakBuiltinRunner { _ => return Ok(None), }; - input_felts_u64.push(val) + input_felts.push(val) } - let input_message: Vec = input_felts_u64 + let input_message: Vec = input_felts .iter() - .flat_map(|x| Self::right_pad(&mut x.to_biguint().to_bytes_le(), KECCAK_FELT_BYTE_SIZE)) + .flat_map(|x| Self::right_pad(&x.to_biguint().to_bytes_le(), KECCAK_FELT_BYTE_SIZE)) .collect(); - // keccak_f start: - let bigint = BigUint::from_bytes_le(&input_message); - let mut keccak_input = vec![]; - let w = 64; - for i in 0..25 { - keccak_input.push( - ((&bigint >> (i * w)) & (BigUint::from(2_u8).pow(w) - BigUint::one())) - .to_u64() - .ok_or(RunnerError::KeccakInputCellsNotU64)?, - ) - } - // This unwrap wont fail as the vec is 25 elements long // use from_fn here - let mut keccak_input: [u64; 25] = keccak_input.try_into().unwrap(); - keccak::f1600(&mut keccak_input); - let keccak_result = keccak_input - .iter() - .enumerate() - .map(|(i, x)| BigUint::from(*x) << (i * w as usize)) - .sum::() - .to_bytes_le(); - // keccak_f end + let keccak_result = Self::keccak_f(&input_message)?; + let mut start_index = 0_usize; for (i, bits) in self.state_rep.iter().enumerate() { let end_index = start_index + *bits as usize / 8; @@ -279,6 +260,28 @@ impl KeccakBuiltinRunner { bytes_vector.extend(zeros); bytes_vector } + + fn keccak_f(input_message: &[u8]) -> Result, RunnerError> { + let bigint = BigUint::from_bytes_le(input_message); + let mut keccak_input = vec![]; + let w = 64; + for i in 0..25 { + keccak_input.push( + ((&bigint >> (i * w)) & (BigUint::from(2_u8).pow(w) - BigUint::one())) + .to_u64() + .ok_or(RunnerError::KeccakInputCellsNotU64)?, + ) + } + // This unwrap wont fail as the vec is 25 elements long // use from_fn here + let mut keccak_input: [u64; 25] = keccak_input.try_into().unwrap(); + keccak::f1600(&mut keccak_input); + Ok(keccak_input + .iter() + .enumerate() + .map(|(i, x)| BigUint::from(*x) << (i * w as usize)) + .sum::() + .to_bytes_le()) + } } #[cfg(test)] From ddb03016014db5b662bd34ba02b32a9151cf680f Mon Sep 17 00:00:00 2001 From: Federica Date: Fri, 3 Mar 2023 17:22:16 -0300 Subject: [PATCH 08/38] Refactor --- src/vm/runners/builtin_runner/keccak.rs | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-) diff --git a/src/vm/runners/builtin_runner/keccak.rs b/src/vm/runners/builtin_runner/keccak.rs index 4f6e5402bc..08e8e0c29a 100644 --- a/src/vm/runners/builtin_runner/keccak.rs +++ b/src/vm/runners/builtin_runner/keccak.rs @@ -263,16 +263,15 @@ impl KeccakBuiltinRunner { fn keccak_f(input_message: &[u8]) -> Result, RunnerError> { let bigint = BigUint::from_bytes_le(input_message); - let mut keccak_input = vec![]; + let w = 64; - for i in 0..25 { - keccak_input.push( - ((&bigint >> (i * w)) & (BigUint::from(2_u8).pow(w) - BigUint::one())) - .to_u64() - .ok_or(RunnerError::KeccakInputCellsNotU64)?, - ) - } - // This unwrap wont fail as the vec is 25 elements long // use from_fn here + let keccak_input = (0..25) + .map(|i| { + ((&bigint >> (i * w)) & (BigUint::from(2_u8).pow(w) - BigUint::one())).to_u64() + }) + .collect::>>() + .ok_or(RunnerError::KeccakInputCellsNotU64)?; + // This unwrap wont fail as keccak_input is created from a (0..25) range let mut keccak_input: [u64; 25] = keccak_input.try_into().unwrap(); keccak::f1600(&mut keccak_input); Ok(keccak_input From 792a0119987e11eefafda81af9d5caa764fbea38 Mon Sep 17 00:00:00 2001 From: Federica Date: Fri, 3 Mar 2023 17:27:57 -0300 Subject: [PATCH 09/38] Add tests --- src/vm/runners/builtin_runner/keccak.rs | 16 +++++++++++++++- 1 file changed, 15 insertions(+), 1 deletion(-) diff --git a/src/vm/runners/builtin_runner/keccak.rs b/src/vm/runners/builtin_runner/keccak.rs index 08e8e0c29a..986c97ce2d 100644 --- a/src/vm/runners/builtin_runner/keccak.rs +++ b/src/vm/runners/builtin_runner/keccak.rs @@ -263,7 +263,6 @@ impl KeccakBuiltinRunner { fn keccak_f(input_message: &[u8]) -> Result, RunnerError> { let bigint = BigUint::from_bytes_le(input_message); - let w = 64; let keccak_input = (0..25) .map(|i| { @@ -702,4 +701,19 @@ mod tests { assert_eq!(result, 16384); } + + #[test] + fn right_pad() { + let num = [1_u8]; + let padded_num = KeccakBuiltinRunner::right_pad(&num, 5); + assert_eq!(padded_num, vec![1, 0, 0, 0, 0]); + } + + #[test] + fn keccak_f() { + let input_bytes = b"\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"; + let expected_output_bytes = b"\xf6\x98\x81\xe1\x00!\x1f.\xc4*\x8c\x0c\x7fF\xc8q8\xdf\xb9\xbe\x07H\xca7T1\xab\x16\x17\xa9\x11\xff-L\x87\xb2iY.\x96\x82x\xde\xbb\\up?uz:0\xee\x08\x1b\x15\xd6\n\xab\r\x0b\x87T:w\x0fH\xe7!f},\x08a\xe5\xbe8\x16\x13\x9a?\xad~<9\xf7\x03`\x8b\xd8\xa3F\x8aQ\xf9\n9\xcdD\xb7.X\xf7\x8e\x1f\x17\x9e \xe5i\x01rr\xdf\xaf\x99k\x9f\x8e\x84\\\xday`\xf1``\x02q+\x8e\xad\x96\xd8\xff\xff3<\xb6\x01o\xd7\xa6\x86\x9d\xea\xbc\xfb\x08\xe1\xa3\x1c\x06z\xab@\xa1\xc1\xb1xZ\x92\x96\xc0.\x01\x13g\x93\x87!\xa6\xa8z\x9c@\x0bY'\xe7\xa7Qr\xe5\xc1\xa3\xa6\x88H\xa5\xc0@9k:y\xd1Kw\xd5"; + let output_bytes = KeccakBuiltinRunner::keccak_f(input_bytes); + assert_eq!(output_bytes, Ok(expected_output_bytes.to_vec())); + } } From f5b43c615144a4090e6d2be80555cbd967239fa2 Mon Sep 17 00:00:00 2001 From: Federica Date: Fri, 3 Mar 2023 17:38:30 -0300 Subject: [PATCH 10/38] Fix address management --- src/vm/runners/builtin_runner/keccak.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/vm/runners/builtin_runner/keccak.rs b/src/vm/runners/builtin_runner/keccak.rs index 986c97ce2d..3840fee458 100644 --- a/src/vm/runners/builtin_runner/keccak.rs +++ b/src/vm/runners/builtin_runner/keccak.rs @@ -85,6 +85,7 @@ impl KeccakBuiltinRunner { let first_input_addr = address .sub_usize(index) .map_err(|_| RunnerError::KeccakNoFirstInput)?; + let first_output_addr = first_input_addr + self.n_input_cells as usize; let mut input_felts = vec![]; @@ -119,14 +120,13 @@ impl KeccakBuiltinRunner { for (i, bits) in self.state_rep.iter().enumerate() { let end_index = start_index + *bits as usize / 8; self.cache.borrow_mut().insert( - first_input_addr + i, + first_output_addr + i, Felt::from(BigUint::from_bytes_le( &keccak_result[start_index..end_index], )), ); start_index = end_index; } - dbg!(&self.cache); Ok(self.cache.borrow().get(&address).map(|x| x.into())) } From 9815ff1f2d5eb22fdbffc4f62231aa4ae9a118af Mon Sep 17 00:00:00 2001 From: Federica Date: Fri, 3 Mar 2023 17:41:54 -0300 Subject: [PATCH 11/38] Add test program --- cairo_programs/keccak_builtin.cairo | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 cairo_programs/keccak_builtin.cairo diff --git a/cairo_programs/keccak_builtin.cairo b/cairo_programs/keccak_builtin.cairo new file mode 100644 index 0000000000..41d0b80688 --- /dev/null +++ b/cairo_programs/keccak_builtin.cairo @@ -0,0 +1,19 @@ +%builtins keccak + from starkware.cairo.common.cairo_builtins import KeccakBuiltin + from starkware.cairo.common.keccak_state import KeccakBuiltinState + from starkware.cairo.common.serialize import serialize_word + + func main{keccak_ptr: KeccakBuiltin*}() { + assert keccak_ptr[0].input = KeccakBuiltinState(1,2,3,4,5,6,7,8); + let result = keccak_ptr[0].output; + let keccak_ptr = keccak_ptr + KeccakBuiltin.SIZE; + assert result.s0 = 528644516554364142278482415480021626364691973678134577961206; + assert result.s1 = 768681319646568210457759892191562701823009052229295869963057; + assert result.s2 = 1439835513376369408063324968379272676079109225238241190228026; + assert result.s3 = 1150396629165612276474514703759718478742374517669870754478270; + assert result.s4 = 1515147102575186161827863034255579930572231617017100845406254; + assert result.s5 = 1412568161597072838250338588041800080889949791225997426843744; + assert result.s6 = 982235455376248641031519404605670648838699214888770304613539; + assert result.s7 = 1339947803093378278438908448344904300127577306141693325151040; + return (); +} From de8965894160b6f3042a5137240df67775b8af27 Mon Sep 17 00:00:00 2001 From: Federica Date: Fri, 3 Mar 2023 17:59:53 -0300 Subject: [PATCH 12/38] Clippy + Update tests --- src/vm/runners/builtin_runner/bitwise.rs | 4 +- src/vm/runners/builtin_runner/keccak.rs | 81 ++++++++++++------------ 2 files changed, 42 insertions(+), 43 deletions(-) diff --git a/src/vm/runners/builtin_runner/bitwise.rs b/src/vm/runners/builtin_runner/bitwise.rs index 310d3babec..ee9a021132 100644 --- a/src/vm/runners/builtin_runner/bitwise.rs +++ b/src/vm/runners/builtin_runner/bitwise.rs @@ -87,14 +87,14 @@ impl BitwiseBuiltinRunner { ) { if num_x.bits() > self.bitwise_builtin.total_n_bits as u64 { return Err(RunnerError::IntegerBiggerThanPowerOfTwo( - x_addr.into(), + x_addr, self.bitwise_builtin.total_n_bits, num_x.clone(), )); }; if num_y.bits() > self.bitwise_builtin.total_n_bits as u64 { return Err(RunnerError::IntegerBiggerThanPowerOfTwo( - y_addr.into(), + y_addr, self.bitwise_builtin.total_n_bits, num_y.clone(), )); diff --git a/src/vm/runners/builtin_runner/keccak.rs b/src/vm/runners/builtin_runner/keccak.rs index 3840fee458..ab6fc14131 100644 --- a/src/vm/runners/builtin_runner/keccak.rs +++ b/src/vm/runners/builtin_runner/keccak.rs @@ -81,10 +81,8 @@ impl KeccakBuiltinRunner { if let Some(felt) = self.cache.borrow().get(&address) { return Ok(Some(felt.into())); } - - let first_input_addr = address - .sub_usize(index) - .map_err(|_| RunnerError::KeccakNoFirstInput)?; + // index will always be less than address.offset, so we can safely unwrap here + let first_input_addr = address.sub_usize(index).unwrap(); let first_output_addr = first_input_addr + self.n_input_cells as usize; let mut input_felts = vec![]; @@ -284,6 +282,8 @@ impl KeccakBuiltinRunner { #[cfg(test)] mod tests { + use num_traits::Num; + use super::*; use crate::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::BuiltinHintProcessor; use crate::relocatable; @@ -564,9 +564,13 @@ mod tests { let result = builtin.deduce_memory_cell(Relocatable::from((0, 25)), &memory); assert_eq!( result, - Ok(Some(MaybeRelocatable::from(Felt::new( - 3086936446498698982_u64 - )))) + Ok(Some(MaybeRelocatable::from( + Felt::from_str_radix( + "1006979841721999878391288827876533441431370448293338267890891", + 10 + ) + .unwrap() + ))) ); } @@ -593,53 +597,48 @@ mod tests { } #[test] - fn deduce_memory_cell_offset_first_addr_error() { - let memory = memory![ - ((0, 16), 43), - ((0, 17), 199), - ((0, 18), 0), - ((0, 19), 0), - ((0, 20), 0), - ((0, 21), 0), - ((0, 22), 0), - ((0, 23), 1), - ((0, 24), 0), - ((0, 25), 0), - ((0, 26), 43), - ((0, 27), 199), - ((0, 28), 0), - ((0, 29), 0), - ((0, 30), 0), - ((0, 31), 0), - ((0, 32), 0), - ((0, 33), 1), - ((0, 34), 0), - ((0, 35), 0) - ]; + fn deduce_memory_cell_expected_integer() { + let memory = memory![((0, 0), (1, 2))]; - let builtin = KeccakBuiltinRunner::new(&KeccakInstanceDef::default(), true); + let mut builtin = KeccakBuiltinRunner::new(&KeccakInstanceDef::default(), true); + + builtin.n_input_cells = 1; + builtin.cells_per_instance = 100; + + let result = builtin.deduce_memory_cell(Relocatable::from((0, 1)), &memory); + + assert_eq!( + result, + Err(RunnerError::KeccakExpectedInteger((0, 0).into())) + ); + } + + #[test] + fn deduce_memory_cell_missing_input_cells() { + let memory = memory![((0, 1), (1, 2))]; + + let mut builtin = KeccakBuiltinRunner::new(&KeccakInstanceDef::default(), true); + + builtin.n_input_cells = 1; + builtin.cells_per_instance = 100; + + let result = builtin.deduce_memory_cell(Relocatable::from((0, 1)), &memory); - let result = builtin.deduce_memory_cell(Relocatable::from((0, 25)), &memory); assert_eq!(result, Ok(None)); } #[test] - fn deduce_memory_cell_expected_integer() { + fn deduce_memory_cell_input_cell() { let memory = memory![((0, 0), (1, 2))]; let mut builtin = KeccakBuiltinRunner::new(&KeccakInstanceDef::default(), true); - builtin.n_input_cells = 0; + builtin.n_input_cells = 1; builtin.cells_per_instance = 100; - let result = builtin.deduce_memory_cell(Relocatable::from((0, 99)), &memory); + let result = builtin.deduce_memory_cell(Relocatable::from((0, 0)), &memory); - assert_eq!( - result, - Err(RunnerError::Memory(MemoryError::ExpectedInteger( - (0, 0).into() - ))) - ); + assert_eq!(result, Ok(None)); } #[test] From dcf47d2e75b055a8b10ad237c3dd77772ab881a4 Mon Sep 17 00:00:00 2001 From: Federica Date: Fri, 3 Mar 2023 18:06:38 -0300 Subject: [PATCH 13/38] Remove unused import --- cairo_programs/keccak_builtin.cairo | 1 - 1 file changed, 1 deletion(-) diff --git a/cairo_programs/keccak_builtin.cairo b/cairo_programs/keccak_builtin.cairo index 41d0b80688..2f7b9bf429 100644 --- a/cairo_programs/keccak_builtin.cairo +++ b/cairo_programs/keccak_builtin.cairo @@ -1,7 +1,6 @@ %builtins keccak from starkware.cairo.common.cairo_builtins import KeccakBuiltin from starkware.cairo.common.keccak_state import KeccakBuiltinState - from starkware.cairo.common.serialize import serialize_word func main{keccak_ptr: KeccakBuiltin*}() { assert keccak_ptr[0].input = KeccakBuiltinState(1,2,3,4,5,6,7,8); From 93f0517b4a8517fb2b217fed514690bdf096a735 Mon Sep 17 00:00:00 2001 From: Federica Date: Fri, 3 Mar 2023 18:41:23 -0300 Subject: [PATCH 14/38] Remove uneeded Rc --- src/vm/runners/builtin_runner/keccak.rs | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/src/vm/runners/builtin_runner/keccak.rs b/src/vm/runners/builtin_runner/keccak.rs index ab6fc14131..723e9e4207 100644 --- a/src/vm/runners/builtin_runner/keccak.rs +++ b/src/vm/runners/builtin_runner/keccak.rs @@ -1,6 +1,5 @@ use std::cell::RefCell; use std::collections::HashMap; -use std::rc::Rc; use crate::math_utils::safe_div_usize; use crate::types::instance_definitions::keccak_instance_def::KeccakInstanceDef; @@ -29,7 +28,7 @@ pub struct KeccakBuiltinRunner { pub(crate) included: bool, state_rep: Vec, instances_per_component: u32, - cache: Rc>>, + cache: RefCell>, } impl KeccakBuiltinRunner { @@ -43,7 +42,7 @@ impl KeccakBuiltinRunner { included, instances_per_component: instance_def._instance_per_component, state_rep: instance_def._state_rep.clone(), - cache: Rc::new(RefCell::new(HashMap::new())), + cache: RefCell::new(HashMap::new()), } } From 8df2af6762d2506aecb3bb56dfa1dc255a7df41e Mon Sep 17 00:00:00 2001 From: Federica Date: Mon, 6 Mar 2023 10:20:54 -0300 Subject: [PATCH 15/38] Make error less specific --- src/vm/errors/runner_errors.rs | 4 ++-- src/vm/runners/builtin_runner/keccak.rs | 10 ++++++++-- 2 files changed, 10 insertions(+), 4 deletions(-) diff --git a/src/vm/errors/runner_errors.rs b/src/vm/errors/runner_errors.rs index 6abfe8800b..e6af3c3e4d 100644 --- a/src/vm/errors/runner_errors.rs +++ b/src/vm/errors/runner_errors.rs @@ -79,8 +79,8 @@ pub enum RunnerError { Memory(#[from] MemoryError), #[error("keccak_builtin: Failed to get first input address")] KeccakNoFirstInput, - #[error("keccak_builtin: Expected integer at address {0}")] - KeccakExpectedInteger(Relocatable), + #[error("{0}: Expected integer at address {1}")] + BuiltinExpectedInteger(&'static str, Relocatable), #[error("keccak_builtin: Failed to convert input cells to u64 values")] KeccakInputCellsNotU64, } diff --git a/src/vm/runners/builtin_runner/keccak.rs b/src/vm/runners/builtin_runner/keccak.rs index 723e9e4207..be92e7a797 100644 --- a/src/vm/runners/builtin_runner/keccak.rs +++ b/src/vm/runners/builtin_runner/keccak.rs @@ -91,7 +91,10 @@ impl KeccakBuiltinRunner { Some(value) => { let num = value .get_int_ref() - .ok_or(RunnerError::KeccakExpectedInteger(first_input_addr + i))?; + .ok_or(RunnerError::BuiltinExpectedInteger( + KECCAK_BUILTIN_NAME, + first_input_addr + i, + ))?; if num >= &(Felt::one() << self.state_rep[i]) { return Err(RunnerError::IntegerBiggerThanPowerOfTwo( first_input_addr + i, @@ -608,7 +611,10 @@ mod tests { assert_eq!( result, - Err(RunnerError::KeccakExpectedInteger((0, 0).into())) + Err(RunnerError::BuiltinExpectedInteger( + KECCAK_BUILTIN_NAME, + (0, 0).into() + )) ); } From 569127643806df7afd865dc8b10b25d2ba4ab131 Mon Sep 17 00:00:00 2001 From: Federica Date: Mon, 6 Mar 2023 10:24:00 -0300 Subject: [PATCH 16/38] Add integration test --- tests/cairo_run_test.rs | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/tests/cairo_run_test.rs b/tests/cairo_run_test.rs index d4b7bd88aa..37980b4020 100644 --- a/tests/cairo_run_test.rs +++ b/tests/cairo_run_test.rs @@ -1317,3 +1317,18 @@ fn cairo_run_verify_signature_hint() { ) .expect("Couldn't run program"); } + +#[test] +fn cairo_run_keccak_builtin() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let cairo_run_config = cairo_run::CairoRunConfig { + layout: "recursive", + ..cairo_vm::cairo_run::CairoRunConfig::default() + }; + cairo_run::cairo_run( + Path::new("cairo_programs/keccak_builtin.json"), + &cairo_run_config, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} From a21dec74f4aab6d1b9c84282c807893c47106af7 Mon Sep 17 00:00:00 2001 From: Federica Date: Tue, 7 Mar 2023 10:38:01 -0300 Subject: [PATCH 17/38] Add proposed changes --- src/vm/runners/builtin_runner/keccak.rs | 20 +++++--------------- 1 file changed, 5 insertions(+), 15 deletions(-) diff --git a/src/vm/runners/builtin_runner/keccak.rs b/src/vm/runners/builtin_runner/keccak.rs index be92e7a797..a3be27bcbd 100644 --- a/src/vm/runners/builtin_runner/keccak.rs +++ b/src/vm/runners/builtin_runner/keccak.rs @@ -12,7 +12,7 @@ use crate::vm::vm_memory::memory_segments::MemorySegmentManager; use felt::Felt; use num_bigint::BigUint; use num_integer::div_ceil; -use num_traits::{One, ToPrimitive}; +use num_traits::One; use super::KECCAK_BUILTIN_NAME; @@ -263,22 +263,12 @@ impl KeccakBuiltinRunner { fn keccak_f(input_message: &[u8]) -> Result, RunnerError> { let bigint = BigUint::from_bytes_le(input_message); - let w = 64; - let keccak_input = (0..25) - .map(|i| { - ((&bigint >> (i * w)) & (BigUint::from(2_u8).pow(w) - BigUint::one())).to_u64() - }) - .collect::>>() - .ok_or(RunnerError::KeccakInputCellsNotU64)?; - // This unwrap wont fail as keccak_input is created from a (0..25) range + let mut keccak_input = bigint.to_u64_digits(); + keccak_input.resize(25, 0); + // This unwrap wont fail as keccak_input's size is always 25 let mut keccak_input: [u64; 25] = keccak_input.try_into().unwrap(); keccak::f1600(&mut keccak_input); - Ok(keccak_input - .iter() - .enumerate() - .map(|(i, x)| BigUint::from(*x) << (i * w as usize)) - .sum::() - .to_bytes_le()) + Ok(keccak_input.iter().flat_map(|x| x.to_le_bytes()).collect()) } } From f72a10307bd9e9658bee69848c682096fa70b882 Mon Sep 17 00:00:00 2001 From: Federica Date: Wed, 8 Mar 2023 11:45:16 -0300 Subject: [PATCH 18/38] Add new hints --- .../builtin_hint_processor_definition.rs | 8 +++++ .../builtin_hint_processor/hint_code.rs | 5 +++ .../builtin_hint_processor/keccak_utils.rs | 32 +++++++++++++++++++ 3 files changed, 45 insertions(+) diff --git a/src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs b/src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs index db4dd67767..d7686bb3a7 100644 --- a/src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs +++ b/src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs @@ -65,6 +65,8 @@ use std::{any::Any, collections::HashMap, rc::Rc}; #[cfg(feature = "skip_next_instruction_hint")] use crate::hint_processor::builtin_hint_processor::skip_next_instruction::skip_next_instruction; +use super::keccak_utils::{split_output_0, split_output_1}; + pub struct HintProcessorData { pub code: String, pub ap_tracking: ApTracking, @@ -437,6 +439,12 @@ impl HintProcessor for BuiltinHintProcessor { hint_code::VERIFY_ECDSA_SIGNATURE => { verify_ecdsa_signature(vm, &hint_data.ids_data, &hint_data.ap_tracking) } + hint_code::SPLIT_OUTPUT_0 => { + split_output_0(vm, &hint_data.ids_data, &hint_data.ap_tracking) + } + hint_code::SPLIT_OUTPUT_1 => { + split_output_1(vm, &hint_data.ids_data, &hint_data.ap_tracking) + } #[cfg(feature = "skip_next_instruction_hint")] hint_code::SKIP_NEXT_INSTRUCTION => skip_next_instruction(vm), code => Err(HintError::UnknownHint(code.to_string())), diff --git a/src/hint_processor/builtin_hint_processor/hint_code.rs b/src/hint_processor/builtin_hint_processor/hint_code.rs index d529b9820f..27cb451717 100644 --- a/src/hint_processor/builtin_hint_processor/hint_code.rs +++ b/src/hint_processor/builtin_hint_processor/hint_code.rs @@ -541,5 +541,10 @@ pub(crate) const RELOCATE_SEGMENT: &str = pub(crate) const TEMPORARY_ARRAY: &str = r#"ids.temporary_array = segments.add_temp_segment()"#; pub(crate) const VERIFY_ECDSA_SIGNATURE: &str = r#"ecdsa_builtin.add_signature(ids.ecdsa_ptr.address_, (ids.signature_r, ids.signature_s))"#; + +pub(crate) const SPLIT_OUTPUT_0: &str = "ids.output0_low = ids.output0 & ((1 << 128) - 1) +ids.output0_high = ids.output0 >> 128"; +pub(crate) const SPLIT_OUTPUT_1: &str = "ids.output1_low = ids.output1 & ((1 << 128) - 1) +ids.output1_high = ids.output1 >> 128"; #[cfg(feature = "skip_next_instruction_hint")] pub(crate) const SKIP_NEXT_INSTRUCTION: &str = "skip_next_instruction()"; diff --git a/src/hint_processor/builtin_hint_processor/keccak_utils.rs b/src/hint_processor/builtin_hint_processor/keccak_utils.rs index ff3e1ab612..816480d4fa 100644 --- a/src/hint_processor/builtin_hint_processor/keccak_utils.rs +++ b/src/hint_processor/builtin_hint_processor/keccak_utils.rs @@ -14,6 +14,8 @@ use num_traits::{One, Signed, ToPrimitive}; use sha3::{Digest, Keccak256}; use std::{cmp, collections::HashMap, ops::Shl}; +use super::hint_utils::insert_value_from_var_name; + /* Implements hint: %{ from eth_hash.auto import keccak @@ -180,3 +182,33 @@ fn left_pad(bytes_vector: &mut [u8], n_zeros: usize) -> Vec { res } + +// Implements hint: ids.output0_low = ids.output0 & ((1 << 128) - 1) +// ids.output0_high = ids.output0 >> 128 +pub fn split_output_0( + vm: &mut VirtualMachine, + ids_data: &HashMap, + ap_tracking: &ApTracking, +) -> Result<(), HintError> { + let output_cow = get_integer_from_var_name("output0", vm, ids_data, ap_tracking)?; + let output = output_cow.as_ref(); + let low = output & ((Felt::one() << 128_u32) - 1_u32); + let high = output >> 128; + insert_value_from_var_name("output0_high", high, vm, ids_data, ap_tracking)?; + insert_value_from_var_name("output0_low", low, vm, ids_data, ap_tracking) +} + +// Implements hint: ids.output1_low = ids.output1 & ((1 << 128) - 1) +// ids.output1_high = ids.output1 >> 128 +pub fn split_output_1( + vm: &mut VirtualMachine, + ids_data: &HashMap, + ap_tracking: &ApTracking, +) -> Result<(), HintError> { + let output_cow = get_integer_from_var_name("output1", vm, ids_data, ap_tracking)?; + let output = output_cow.as_ref(); + let low = output & ((Felt::one() << 128_u32) - 1_u32); + let high = output >> 128; + insert_value_from_var_name("output1_high", high, vm, ids_data, ap_tracking)?; + insert_value_from_var_name("output1_low", low, vm, ids_data, ap_tracking) +} From 589d9c36059ec8beefc83eaf57bb6dcb396882a7 Mon Sep 17 00:00:00 2001 From: Federica Date: Wed, 8 Mar 2023 11:45:39 -0300 Subject: [PATCH 19/38] Add test program --- cairo_programs/keccak_uint256.cairo | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 cairo_programs/keccak_uint256.cairo diff --git a/cairo_programs/keccak_uint256.cairo b/cairo_programs/keccak_uint256.cairo new file mode 100644 index 0000000000..61ce327789 --- /dev/null +++ b/cairo_programs/keccak_uint256.cairo @@ -0,0 +1,19 @@ +%builtins range_check bitwise keccak +from starkware.cairo.common.cairo_builtins import KeccakBuiltin, BitwiseBuiltin +from starkware.cairo.common.builtin_keccak.keccak import keccak_uint256s +from starkware.cairo.common.alloc import alloc +from starkware.cairo.common.uint256 import Uint256 + +func main{range_check_ptr, bitwise_ptr: BitwiseBuiltin*, keccak_ptr: KeccakBuiltin*}() { + let elements: Uint256* = alloc(); + assert elements[0] = Uint256(713458135386519, 18359173571); + assert elements[1] = Uint256(1536741637546373185, 84357893467438914); + assert elements[2] = Uint256(2842949328439284983294, 39248298942938492384); + assert elements[3] = Uint256(27518568234293478923754395731931, 981587843715983274); + assert elements[4] = Uint256(326848123647324823482, 93453458349589345); + let (res) = keccak_uint256s(5, elements); + assert res.high = 7; + assert res.low =8; + + return (); +} \ No newline at end of file From cba813f85333dfbfb85c34838e172053971315a5 Mon Sep 17 00:00:00 2001 From: Federica Date: Wed, 8 Mar 2023 11:45:52 -0300 Subject: [PATCH 20/38] Move constants --- .../builtin_hint_processor/cairo_keccak/keccak_hints.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/hint_processor/builtin_hint_processor/cairo_keccak/keccak_hints.rs b/src/hint_processor/builtin_hint_processor/cairo_keccak/keccak_hints.rs index a6a0646f7e..b4f846784f 100644 --- a/src/hint_processor/builtin_hint_processor/cairo_keccak/keccak_hints.rs +++ b/src/hint_processor/builtin_hint_processor/cairo_keccak/keccak_hints.rs @@ -16,12 +16,12 @@ use felt::Felt; use num_traits::{ToPrimitive, Zero}; use std::{borrow::Cow, collections::HashMap}; -// Constants in package "starkware.cairo.common.cairo_keccak.keccak". -const BYTES_IN_WORD: &str = "starkware.cairo.common.cairo_keccak.keccak.BYTES_IN_WORD"; +// Constants in package "starkware.cairo.common.builtin_keccak.keccak". +const BYTES_IN_WORD: &str = "starkware.cairo.common.builtin_keccak.keccak.BYTES_IN_WORD"; const KECCAK_FULL_RATE_IN_BYTES: &str = - "starkware.cairo.common.cairo_keccak.keccak.KECCAK_FULL_RATE_IN_BYTES"; + "starkware.cairo.common.builtin_keccak.keccak.KECCAK_FULL_RATE_IN_BYTES"; const KECCAK_STATE_SIZE_FELTS: &str = - "starkware.cairo.common.cairo_keccak.keccak.KECCAK_STATE_SIZE_FELTS"; + "starkware.cairo.common.builtin_keccak.keccak.KECCAK_STATE_SIZE_FELTS"; // Constants in package "starkware.cairo.common.cairo_keccak.packed_keccak". const BLOCK_SIZE: &str = "starkware.cairo.common.cairo_keccak.packed_keccak.BLOCK_SIZE"; From f508f61a901b734f91ef77e147d9444953664e59 Mon Sep 17 00:00:00 2001 From: Federica Date: Wed, 8 Mar 2023 12:30:46 -0300 Subject: [PATCH 21/38] Add keccak hints; --- .../builtin_hint_processor_definition.rs | 23 +++++++-- .../builtin_hint_processor/hint_code.rs | 11 ++++ .../builtin_hint_processor/keccak_utils.rs | 50 +++++++++++++------ 3 files changed, 65 insertions(+), 19 deletions(-) diff --git a/src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs b/src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs index d7686bb3a7..cf15df667b 100644 --- a/src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs +++ b/src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs @@ -14,7 +14,7 @@ use crate::{ }, find_element_hint::{find_element, search_sorted_lower}, hint_code, - keccak_utils::{unsafe_keccak, unsafe_keccak_finalize}, + keccak_utils::{split_input, split_output, unsafe_keccak, unsafe_keccak_finalize}, math_utils::*, memcpy_hint_utils::{ add_segment, enter_scope, exit_scope, memcpy_continue_copying, memcpy_enter_scope, @@ -65,8 +65,6 @@ use std::{any::Any, collections::HashMap, rc::Rc}; #[cfg(feature = "skip_next_instruction_hint")] use crate::hint_processor::builtin_hint_processor::skip_next_instruction::skip_next_instruction; -use super::keccak_utils::{split_output_0, split_output_1}; - pub struct HintProcessorData { pub code: String, pub ap_tracking: ApTracking, @@ -440,10 +438,25 @@ impl HintProcessor for BuiltinHintProcessor { verify_ecdsa_signature(vm, &hint_data.ids_data, &hint_data.ap_tracking) } hint_code::SPLIT_OUTPUT_0 => { - split_output_0(vm, &hint_data.ids_data, &hint_data.ap_tracking) + split_output(vm, &hint_data.ids_data, &hint_data.ap_tracking, 0) } hint_code::SPLIT_OUTPUT_1 => { - split_output_1(vm, &hint_data.ids_data, &hint_data.ap_tracking) + split_output(vm, &hint_data.ids_data, &hint_data.ap_tracking, 1) + } + hint_code::SPLIT_INPUT_3 => { + split_input(vm, &hint_data.ids_data, &hint_data.ap_tracking, 3, 1) + } + hint_code::SPLIT_INPUT_6 => { + split_input(vm, &hint_data.ids_data, &hint_data.ap_tracking, 6, 2) + } + hint_code::SPLIT_INPUT_9 => { + split_input(vm, &hint_data.ids_data, &hint_data.ap_tracking, 9, 3) + } + hint_code::SPLIT_INPUT_12 => { + split_input(vm, &hint_data.ids_data, &hint_data.ap_tracking, 12, 4) + } + hint_code::SPLIT_INPUT_15 => { + split_input(vm, &hint_data.ids_data, &hint_data.ap_tracking, 15, 5) } #[cfg(feature = "skip_next_instruction_hint")] hint_code::SKIP_NEXT_INSTRUCTION => skip_next_instruction(vm), diff --git a/src/hint_processor/builtin_hint_processor/hint_code.rs b/src/hint_processor/builtin_hint_processor/hint_code.rs index 27cb451717..1f9f2b594d 100644 --- a/src/hint_processor/builtin_hint_processor/hint_code.rs +++ b/src/hint_processor/builtin_hint_processor/hint_code.rs @@ -546,5 +546,16 @@ pub(crate) const SPLIT_OUTPUT_0: &str = "ids.output0_low = ids.output0 & ((1 << ids.output0_high = ids.output0 >> 128"; pub(crate) const SPLIT_OUTPUT_1: &str = "ids.output1_low = ids.output1 & ((1 << 128) - 1) ids.output1_high = ids.output1 >> 128"; + +pub(crate) const SPLIT_INPUT_3: &str = "ids.high3, ids.low3 = divmod(memory[ids.inputs + 3], 256)"; +pub(crate) const SPLIT_INPUT_6: &str = + "ids.high6, ids.low6 = divmod(memory[ids.inputs + 6], 256 ** 2)"; +pub(crate) const SPLIT_INPUT_9: &str = + "ids.high9, ids.low9 = divmod(memory[ids.inputs + 9], 256 ** 3)"; +pub(crate) const SPLIT_INPUT_12: &str = + "ids.high12, ids.low12 = divmod(memory[ids.inputs + 12], 256 ** 4)"; +pub(crate) const SPLIT_INPUT_15: &str = + "ids.high15, ids.low15 = divmod(memory[ids.inputs + 15], 256 ** 5)"; + #[cfg(feature = "skip_next_instruction_hint")] pub(crate) const SKIP_NEXT_INSTRUCTION: &str = "skip_next_instruction()"; diff --git a/src/hint_processor/builtin_hint_processor/keccak_utils.rs b/src/hint_processor/builtin_hint_processor/keccak_utils.rs index 816480d4fa..cf48ac8fb1 100644 --- a/src/hint_processor/builtin_hint_processor/keccak_utils.rs +++ b/src/hint_processor/builtin_hint_processor/keccak_utils.rs @@ -10,7 +10,8 @@ use crate::{ vm::{errors::hint_errors::HintError, vm_core::VirtualMachine}, }; use felt::Felt; -use num_traits::{One, Signed, ToPrimitive}; +use num_integer::Integer; +use num_traits::{One, Pow, Signed, ToPrimitive}; use sha3::{Digest, Keccak256}; use std::{cmp, collections::HashMap, ops::Shl}; @@ -185,30 +186,51 @@ fn left_pad(bytes_vector: &mut [u8], n_zeros: usize) -> Vec { // Implements hint: ids.output0_low = ids.output0 & ((1 << 128) - 1) // ids.output0_high = ids.output0 >> 128 -pub fn split_output_0( +pub fn split_output( vm: &mut VirtualMachine, ids_data: &HashMap, ap_tracking: &ApTracking, + num: u32, ) -> Result<(), HintError> { - let output_cow = get_integer_from_var_name("output0", vm, ids_data, ap_tracking)?; + let output_name = format!("output{}", num); + let output_cow = get_integer_from_var_name(&output_name, vm, ids_data, ap_tracking)?; let output = output_cow.as_ref(); let low = output & ((Felt::one() << 128_u32) - 1_u32); let high = output >> 128; - insert_value_from_var_name("output0_high", high, vm, ids_data, ap_tracking)?; - insert_value_from_var_name("output0_low", low, vm, ids_data, ap_tracking) + insert_value_from_var_name( + &format!("output{}_high", num), + high, + vm, + ids_data, + ap_tracking, + )?; + insert_value_from_var_name( + &format!("output{}_low", num), + low, + vm, + ids_data, + ap_tracking, + ) } -// Implements hint: ids.output1_low = ids.output1 & ((1 << 128) - 1) -// ids.output1_high = ids.output1 >> 128 -pub fn split_output_1( +// Implements hints of type: ids.high{input_key}, ids.low{input_key} = divmod(memory[ids.inputs + {input_key}], 256 ** {exponent}) +pub fn split_input( vm: &mut VirtualMachine, ids_data: &HashMap, ap_tracking: &ApTracking, + input_key: usize, + exponent: u32, ) -> Result<(), HintError> { - let output_cow = get_integer_from_var_name("output1", vm, ids_data, ap_tracking)?; - let output = output_cow.as_ref(); - let low = output & ((Felt::one() << 128_u32) - 1_u32); - let high = output >> 128; - insert_value_from_var_name("output1_high", high, vm, ids_data, ap_tracking)?; - insert_value_from_var_name("output1_low", low, vm, ids_data, ap_tracking) + let inputs_ptr = get_ptr_from_var_name("inputs", vm, ids_data, ap_tracking)?; + let binding = vm.get_integer((inputs_ptr + input_key)?)?; + let third_input = binding.as_ref(); + let (high, low) = third_input.div_rem(&Felt::from(256.pow(exponent))); + insert_value_from_var_name( + &format!("high{}", input_key), + high, + vm, + ids_data, + ap_tracking, + )?; + insert_value_from_var_name(&format!("low{}", input_key), low, vm, ids_data, ap_tracking) } From 6bb9b480b743e9eb7c714dced43b8c5def6f7b8b Mon Sep 17 00:00:00 2001 From: Federica Date: Wed, 8 Mar 2023 12:46:45 -0300 Subject: [PATCH 22/38] Fix overflowing operation --- .../builtin_hint_processor_definition.rs | 1 - src/hint_processor/builtin_hint_processor/keccak_utils.rs | 6 +++--- 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs b/src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs index cf15df667b..7b99c77b70 100644 --- a/src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs +++ b/src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs @@ -134,7 +134,6 @@ impl HintProcessor for BuiltinHintProcessor { constants, ); } - match &*hint_data.code { hint_code::ADD_SEGMENT => add_segment(vm), hint_code::IS_NN => is_nn(vm, &hint_data.ids_data, &hint_data.ap_tracking), diff --git a/src/hint_processor/builtin_hint_processor/keccak_utils.rs b/src/hint_processor/builtin_hint_processor/keccak_utils.rs index cf48ac8fb1..c4eab2d0ff 100644 --- a/src/hint_processor/builtin_hint_processor/keccak_utils.rs +++ b/src/hint_processor/builtin_hint_processor/keccak_utils.rs @@ -11,7 +11,7 @@ use crate::{ }; use felt::Felt; use num_integer::Integer; -use num_traits::{One, Pow, Signed, ToPrimitive}; +use num_traits::{One, Signed, ToPrimitive}; use sha3::{Digest, Keccak256}; use std::{cmp, collections::HashMap, ops::Shl}; @@ -223,8 +223,8 @@ pub fn split_input( ) -> Result<(), HintError> { let inputs_ptr = get_ptr_from_var_name("inputs", vm, ids_data, ap_tracking)?; let binding = vm.get_integer((inputs_ptr + input_key)?)?; - let third_input = binding.as_ref(); - let (high, low) = third_input.div_rem(&Felt::from(256.pow(exponent))); + let input = binding.as_ref(); + let (high, low) = input.div_rem(&Felt::from(256_u64.pow(exponent))); insert_value_from_var_name( &format!("high{}", input_key), high, From 855b2c733a9548ca9829f14d426a3cdc86142515 Mon Sep 17 00:00:00 2001 From: Federica Date: Wed, 8 Mar 2023 13:25:29 -0300 Subject: [PATCH 23/38] Add more hints --- cairo_programs/keccak_uint256.cairo | 4 +- .../builtin_hint_processor_definition.rs | 8 ++++ .../cairo_keccak/keccak_hints.rs | 2 +- .../builtin_hint_processor/hint_code.rs | 6 +++ .../builtin_hint_processor/keccak_utils.rs | 39 +++++++++++++++++-- 5 files changed, 53 insertions(+), 6 deletions(-) diff --git a/cairo_programs/keccak_uint256.cairo b/cairo_programs/keccak_uint256.cairo index 61ce327789..4eec69933e 100644 --- a/cairo_programs/keccak_uint256.cairo +++ b/cairo_programs/keccak_uint256.cairo @@ -12,8 +12,8 @@ func main{range_check_ptr, bitwise_ptr: BitwiseBuiltin*, keccak_ptr: KeccakBuilt assert elements[3] = Uint256(27518568234293478923754395731931, 981587843715983274); assert elements[4] = Uint256(326848123647324823482, 93453458349589345); let (res) = keccak_uint256s(5, elements); - assert res.high = 7; - assert res.low =8; + assert res.high = 23012215180764429403047187376747988760; + assert res.low = 13431206634823648732212765105043225161; return (); } \ No newline at end of file diff --git a/src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs b/src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs index 7b99c77b70..aed7d81121 100644 --- a/src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs +++ b/src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs @@ -65,6 +65,8 @@ use std::{any::Any, collections::HashMap, rc::Rc}; #[cfg(feature = "skip_next_instruction_hint")] use crate::hint_processor::builtin_hint_processor::skip_next_instruction::skip_next_instruction; +use super::keccak_utils::{split_n_bytes, split_output_mid_low_high}; + pub struct HintProcessorData { pub code: String, pub ap_tracking: ApTracking, @@ -457,6 +459,12 @@ impl HintProcessor for BuiltinHintProcessor { hint_code::SPLIT_INPUT_15 => { split_input(vm, &hint_data.ids_data, &hint_data.ap_tracking, 15, 5) } + hint_code::SPLIT_N_BYTES => { + split_n_bytes(vm, &hint_data.ids_data, &hint_data.ap_tracking, constants) + } + hint_code::SPLIT_OUTPUT_MID_LOW_HIGH => { + split_output_mid_low_high(vm, &hint_data.ids_data, &hint_data.ap_tracking) + } #[cfg(feature = "skip_next_instruction_hint")] hint_code::SKIP_NEXT_INSTRUCTION => skip_next_instruction(vm), code => Err(HintError::UnknownHint(code.to_string())), diff --git a/src/hint_processor/builtin_hint_processor/cairo_keccak/keccak_hints.rs b/src/hint_processor/builtin_hint_processor/cairo_keccak/keccak_hints.rs index b4f846784f..b5d7dde524 100644 --- a/src/hint_processor/builtin_hint_processor/cairo_keccak/keccak_hints.rs +++ b/src/hint_processor/builtin_hint_processor/cairo_keccak/keccak_hints.rs @@ -17,7 +17,7 @@ use num_traits::{ToPrimitive, Zero}; use std::{borrow::Cow, collections::HashMap}; // Constants in package "starkware.cairo.common.builtin_keccak.keccak". -const BYTES_IN_WORD: &str = "starkware.cairo.common.builtin_keccak.keccak.BYTES_IN_WORD"; +pub(crate) const BYTES_IN_WORD: &str = "starkware.cairo.common.builtin_keccak.keccak.BYTES_IN_WORD"; const KECCAK_FULL_RATE_IN_BYTES: &str = "starkware.cairo.common.builtin_keccak.keccak.KECCAK_FULL_RATE_IN_BYTES"; const KECCAK_STATE_SIZE_FELTS: &str = diff --git a/src/hint_processor/builtin_hint_processor/hint_code.rs b/src/hint_processor/builtin_hint_processor/hint_code.rs index 1f9f2b594d..904822d0f5 100644 --- a/src/hint_processor/builtin_hint_processor/hint_code.rs +++ b/src/hint_processor/builtin_hint_processor/hint_code.rs @@ -557,5 +557,11 @@ pub(crate) const SPLIT_INPUT_12: &str = pub(crate) const SPLIT_INPUT_15: &str = "ids.high15, ids.low15 = divmod(memory[ids.inputs + 15], 256 ** 5)"; +pub(crate) const SPLIT_N_BYTES: &str = + "ids.n_words_to_copy, ids.n_bytes_left = divmod(ids.n_bytes, ids.BYTES_IN_WORD)"; +pub(crate) const SPLIT_OUTPUT_MID_LOW_HIGH: &str = + "tmp, ids.output1_low = divmod(ids.output1, 256 ** 7) +ids.output1_high, ids.output1_mid = divmod(tmp, 2 ** 128)"; + #[cfg(feature = "skip_next_instruction_hint")] pub(crate) const SKIP_NEXT_INSTRUCTION: &str = "skip_next_instruction()"; diff --git a/src/hint_processor/builtin_hint_processor/keccak_utils.rs b/src/hint_processor/builtin_hint_processor/keccak_utils.rs index c4eab2d0ff..a39810b0db 100644 --- a/src/hint_processor/builtin_hint_processor/keccak_utils.rs +++ b/src/hint_processor/builtin_hint_processor/keccak_utils.rs @@ -15,7 +15,7 @@ use num_traits::{One, Signed, ToPrimitive}; use sha3::{Digest, Keccak256}; use std::{cmp, collections::HashMap, ops::Shl}; -use super::hint_utils::insert_value_from_var_name; +use super::{cairo_keccak::keccak_hints::BYTES_IN_WORD, hint_utils::insert_value_from_var_name}; /* Implements hint: %{ @@ -184,8 +184,8 @@ fn left_pad(bytes_vector: &mut [u8], n_zeros: usize) -> Vec { res } -// Implements hint: ids.output0_low = ids.output0 & ((1 << 128) - 1) -// ids.output0_high = ids.output0 >> 128 +// Implements hints of type : ids.output{num}_low = ids.output{num} & ((1 << 128) - 1) +// ids.output{num}_high = ids.output{num} >> 128 pub fn split_output( vm: &mut VirtualMachine, ids_data: &HashMap, @@ -234,3 +234,36 @@ pub fn split_input( )?; insert_value_from_var_name(&format!("low{}", input_key), low, vm, ids_data, ap_tracking) } + +// Implements hint: ids.n_words_to_copy, ids.n_bytes_left = divmod(ids.n_bytes, ids.BYTES_IN_WORD) +pub fn split_n_bytes( + vm: &mut VirtualMachine, + ids_data: &HashMap, + ap_tracking: &ApTracking, + constants: &HashMap, +) -> Result<(), HintError> { + let n_bytes = get_integer_from_var_name("n_bytes", vm, ids_data, ap_tracking)?; + let bytes_in_word = constants + .get(BYTES_IN_WORD) + .ok_or(HintError::MissingConstant(BYTES_IN_WORD))?; + let (high, low) = n_bytes.div_rem(bytes_in_word); + insert_value_from_var_name("n_words_to_copy", high, vm, ids_data, ap_tracking)?; + insert_value_from_var_name("n_bytes_left", low, vm, ids_data, ap_tracking) +} + +// Implements hint: +// tmp, ids.output1_low = divmod(ids.output1, 256 ** 7) +// ids.output1_high, ids.output1_mid = divmod(tmp, 2 ** 128) +pub fn split_output_mid_low_high( + vm: &mut VirtualMachine, + ids_data: &HashMap, + ap_tracking: &ApTracking, +) -> Result<(), HintError> { + let binding = get_integer_from_var_name("output1", vm, ids_data, ap_tracking)?; + let output1 = binding.as_ref(); + let (tmp, output1_low) = output1.div_rem(&Felt::from(256_u64.pow(7))); + let (output1_high, output1_mid) = tmp.div_rem(&Felt::one().shl(128_u32)); + insert_value_from_var_name("output1_high", output1_high, vm, ids_data, ap_tracking)?; + insert_value_from_var_name("output1_mid", output1_mid, vm, ids_data, ap_tracking)?; + insert_value_from_var_name("output1_low", output1_low, vm, ids_data, ap_tracking) +} From 3a847393db937194eafa9c2f597cd17dbd952379 Mon Sep 17 00:00:00 2001 From: Federica Date: Wed, 8 Mar 2023 15:14:03 -0300 Subject: [PATCH 24/38] Add unit tests --- .../builtin_hint_processor/keccak_utils.rs | 113 ++++++++++++++++++ 1 file changed, 113 insertions(+) diff --git a/src/hint_processor/builtin_hint_processor/keccak_utils.rs b/src/hint_processor/builtin_hint_processor/keccak_utils.rs index a39810b0db..4de77e0b89 100644 --- a/src/hint_processor/builtin_hint_processor/keccak_utils.rs +++ b/src/hint_processor/builtin_hint_processor/keccak_utils.rs @@ -267,3 +267,116 @@ pub fn split_output_mid_low_high( insert_value_from_var_name("output1_mid", output1_mid, vm, ids_data, ap_tracking)?; insert_value_from_var_name("output1_low", output1_low, vm, ids_data, ap_tracking) } + +#[cfg(test)] +mod tests { + use super::*; + use crate::any_box; + use crate::{ + hint_processor::{ + builtin_hint_processor::{ + builtin_hint_processor_definition::{BuiltinHintProcessor, HintProcessorData}, + hint_code, + keccak_utils::HashMap, + }, + hint_processor_definition::{HintProcessor, HintReference}, + }, + types::{exec_scope::ExecutionScopes, relocatable::MaybeRelocatable}, + utils::test_utils::*, + vm::{ + errors::memory_errors::MemoryError, + vm_core::VirtualMachine, + vm_memory::{memory::Memory, memory_segments::MemorySegmentManager}, + }, + }; + use assert_matches::assert_matches; + use std::any::Any; + + #[test] + fn split_output_0() { + let mut vm = vm!(); + vm.segments = segments![((1, 0), 24)]; + vm.set_fp(3); + let ids_data = ids_data!["output0", "output0_high", "output0_low"]; + assert_matches!(run_hint!(vm, ids_data, hint_code::SPLIT_OUTPUT_0), Ok(())); + check_memory!(vm.segments.memory, ((1, 1), 0), ((1, 2), 24)); + } + + #[test] + fn split_output_1() { + let mut vm = vm!(); + vm.segments = segments![((1, 0), 24)]; + vm.set_fp(3); + let ids_data = ids_data!["output1", "output1_high", "output1_low"]; + assert_matches!(run_hint!(vm, ids_data, hint_code::SPLIT_OUTPUT_1), Ok(())); + check_memory!(vm.segments.memory, ((1, 1), 0), ((1, 2), 24)); + } + + #[test] + fn split_input_3() { + let mut vm = vm!(); + vm.segments = segments![((1, 2), (2, 0)), ((2, 3), 300)]; + vm.set_fp(3); + let ids_data = ids_data!["high3", "low3", "inputs"]; + assert_matches!(run_hint!(vm, ids_data, hint_code::SPLIT_INPUT_3), Ok(())); + check_memory!(vm.segments.memory, ((1, 0), 1), ((1, 1), 44)); + } + + #[test] + fn split_input_6() { + let mut vm = vm!(); + vm.segments = segments![((1, 2), (2, 0)), ((2, 6), 66036)]; + vm.set_fp(3); + let ids_data = ids_data!["high6", "low6", "inputs"]; + assert_matches!(run_hint!(vm, ids_data, hint_code::SPLIT_INPUT_6), Ok(())); + check_memory!(vm.segments.memory, ((1, 0), 1), ((1, 1), 500)); + } + + #[test] + fn split_input_15() { + let mut vm = vm!(); + vm.segments = segments![((1, 2), (2, 0)), ((2, 15), 15150315)]; + vm.set_fp(3); + let ids_data = ids_data!["high15", "low15", "inputs"]; + assert_matches!(run_hint!(vm, ids_data, hint_code::SPLIT_INPUT_15), Ok(())); + check_memory!(vm.segments.memory, ((1, 0), 0), ((1, 1), 15150315)); + } + + #[test] + fn split_n_bytes() { + let mut vm = vm!(); + vm.segments = segments![((1, 2), 17)]; + vm.set_fp(3); + let ids_data = ids_data!["n_words_to_copy", "n_bytes_left", "n_bytes"]; + assert_matches!( + run_hint!( + vm, + ids_data, + hint_code::SPLIT_N_BYTES, + exec_scopes_ref!(), + &HashMap::from([(String::from(BYTES_IN_WORD), Felt::from(8))]) + ), + Ok(()) + ); + check_memory!(vm.segments.memory, ((1, 0), 2), ((1, 1), 1)); + } + + #[test] + fn split_output_mid_low_high() { + let mut vm = vm!(); + vm.segments = segments![((1, 0), 72057594037927938)]; + vm.set_fp(4); + let ids_data = ids_data!["output1", "output1_low", "output1_mid", "output1_high"]; + assert_matches!( + run_hint!( + vm, + ids_data, + hint_code::SPLIT_OUTPUT_MID_LOW_HIGH, + exec_scopes_ref!(), + &HashMap::from([(String::from(BYTES_IN_WORD), Felt::from(8))]) + ), + Ok(()) + ); + check_memory!(vm.segments.memory, ((1, 1), 2), ((1, 2), 1), ((1, 3), 0)); + } +} From 573ee4bad009b1a263e7e57f84ebca7243b55ac6 Mon Sep 17 00:00:00 2001 From: Federica Date: Wed, 8 Mar 2023 15:16:01 -0300 Subject: [PATCH 25/38] Add integration test --- tests/cairo_run_test.rs | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/tests/cairo_run_test.rs b/tests/cairo_run_test.rs index 37980b4020..dcf17cb724 100644 --- a/tests/cairo_run_test.rs +++ b/tests/cairo_run_test.rs @@ -1332,3 +1332,18 @@ fn cairo_run_keccak_builtin() { ) .expect("Couldn't run program"); } + +#[test] +fn cairo_run_keccak_uint256() { + let mut hint_executor = BuiltinHintProcessor::new_empty(); + let cairo_run_config = cairo_run::CairoRunConfig { + layout: "recursive", + ..cairo_vm::cairo_run::CairoRunConfig::default() + }; + cairo_run::cairo_run( + Path::new("cairo_programs/keccak_uint256.json"), + &cairo_run_config, + &mut hint_executor, + ) + .expect("Couldn't run program"); +} From 262d8ae7efa39b4fa9295aaae2d3f01dccfe425b Mon Sep 17 00:00:00 2001 From: Federica Date: Wed, 8 Mar 2023 17:46:49 -0300 Subject: [PATCH 26/38] Update import paths in cairo programs used for testing --- cairo_programs/cairo_finalize_keccak.cairo | 4 ++-- cairo_programs/keccak_add_uint256.cairo | 2 +- cairo_programs/keccak_integration_tests.cairo | 5 +++-- 3 files changed, 6 insertions(+), 5 deletions(-) diff --git a/cairo_programs/cairo_finalize_keccak.cairo b/cairo_programs/cairo_finalize_keccak.cairo index 63d24767a1..8adcd515d1 100644 --- a/cairo_programs/cairo_finalize_keccak.cairo +++ b/cairo_programs/cairo_finalize_keccak.cairo @@ -1,6 +1,6 @@ %builtins range_check bitwise -from starkware.cairo.common.cairo_keccak.keccak import keccak, finalize_keccak +from starkware.cairo.common.cairo_keccak.keccak import cairo_keccak, finalize_keccak from starkware.cairo.common.uint256 import Uint256 from starkware.cairo.common.cairo_builtins import BitwiseBuiltin from starkware.cairo.common.alloc import alloc @@ -18,7 +18,7 @@ func main{range_check_ptr: felt, bitwise_ptr: BitwiseBuiltin*}() { let n_bytes = 16; - let (res: Uint256) = keccak{keccak_ptr=keccak_ptr}(inputs=inputs, n_bytes=n_bytes); + let (res: Uint256) = cairo_keccak{keccak_ptr=keccak_ptr}(inputs=inputs, n_bytes=n_bytes); assert res.low = 293431514620200399776069983710520819074; assert res.high = 317109767021952548743448767588473366791; diff --git a/cairo_programs/keccak_add_uint256.cairo b/cairo_programs/keccak_add_uint256.cairo index d54de52963..196adc3fa0 100644 --- a/cairo_programs/keccak_add_uint256.cairo +++ b/cairo_programs/keccak_add_uint256.cairo @@ -1,6 +1,6 @@ %builtins output range_check bitwise -from starkware.cairo.common.cairo_keccak.keccak import keccak_add_uint256 +from starkware.cairo.common.keccak_utils.keccak_utils import keccak_add_uint256 from starkware.cairo.common.uint256 import Uint256 from starkware.cairo.common.cairo_builtins import BitwiseBuiltin from starkware.cairo.common.alloc import alloc diff --git a/cairo_programs/keccak_integration_tests.cairo b/cairo_programs/keccak_integration_tests.cairo index 6ac19341a6..7f4762455b 100644 --- a/cairo_programs/keccak_integration_tests.cairo +++ b/cairo_programs/keccak_integration_tests.cairo @@ -1,7 +1,8 @@ %builtins range_check bitwise from starkware.cairo.common.keccak import unsafe_keccak, unsafe_keccak_finalize, KeccakState -from starkware.cairo.common.cairo_keccak.keccak import keccak_add_uint256, keccak, finalize_keccak +from starkware.cairo.common.cairo_keccak.keccak import cairo_keccak, finalize_keccak +from starkware.cairo.common.keccak_utils.keccak_utils import keccak_add_uint256 from starkware.cairo.common.alloc import alloc from starkware.cairo.common.uint256 import Uint256 from starkware.cairo.common.cairo_builtins import BitwiseBuiltin @@ -56,7 +57,7 @@ func test_integration{range_check_ptr: felt, bitwise_ptr: BitwiseBuiltin*}(iter: let (keccak_ptr: felt*) = alloc(); let keccak_ptr_start = keccak_ptr; - let res_2: Uint256 = keccak{keccak_ptr=keccak_ptr}(data_3, 16); + let res_2: Uint256 = cairo_keccak{keccak_ptr=keccak_ptr}(data_3, 16); finalize_keccak(keccak_ptr_start=keccak_ptr_start, keccak_ptr_end=keccak_ptr); From 9136bb16a0a595b4ad5c0afdb9976c594233280c Mon Sep 17 00:00:00 2001 From: Federica Date: Wed, 8 Mar 2023 17:47:17 -0300 Subject: [PATCH 27/38] Update hints with new import paths --- .../builtin_hint_processor_definition.rs | 7 ++++-- .../cairo_keccak/keccak_hints.rs | 22 ++++++++++++------- .../builtin_hint_processor/hint_code.rs | 2 +- .../builtin_hint_processor/keccak_utils.rs | 4 +++- 4 files changed, 23 insertions(+), 12 deletions(-) diff --git a/src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs b/src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs index aed7d81121..703219c3ee 100644 --- a/src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs +++ b/src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs @@ -6,7 +6,7 @@ use crate::{ }, cairo_keccak::keccak_hints::{ block_permutation, cairo_keccak_finalize, compare_bytes_in_word_nondet, - compare_keccak_full_rate_in_bytes_nondet, keccak_write_args, + keccak_write_args, }, dict_hint_utils::{ default_dict_new, dict_new, dict_read, dict_squash_copy_dict, @@ -65,7 +65,10 @@ use std::{any::Any, collections::HashMap, rc::Rc}; #[cfg(feature = "skip_next_instruction_hint")] use crate::hint_processor::builtin_hint_processor::skip_next_instruction::skip_next_instruction; -use super::keccak_utils::{split_n_bytes, split_output_mid_low_high}; +use super::{ + cairo_keccak::keccak_hints::compare_keccak_full_rate_in_bytes_nondet, + keccak_utils::{split_n_bytes, split_output_mid_low_high}, +}; pub struct HintProcessorData { pub code: String, diff --git a/src/hint_processor/builtin_hint_processor/cairo_keccak/keccak_hints.rs b/src/hint_processor/builtin_hint_processor/cairo_keccak/keccak_hints.rs index b5d7dde524..510e58e956 100644 --- a/src/hint_processor/builtin_hint_processor/cairo_keccak/keccak_hints.rs +++ b/src/hint_processor/builtin_hint_processor/cairo_keccak/keccak_hints.rs @@ -16,12 +16,17 @@ use felt::Felt; use num_traits::{ToPrimitive, Zero}; use std::{borrow::Cow, collections::HashMap}; -// Constants in package "starkware.cairo.common.builtin_keccak.keccak". -pub(crate) const BYTES_IN_WORD: &str = "starkware.cairo.common.builtin_keccak.keccak.BYTES_IN_WORD"; -const KECCAK_FULL_RATE_IN_BYTES: &str = +// Constants in package "starkware.cairo.common.cairo_keccak.keccak". +const BYTES_IN_WORD: &str = "starkware.cairo.common.cairo_keccak.keccak.BYTES_IN_WORD"; +const KECCAK_FULL_RATE_IN_BYTES_CAIRO_KECCAK: &str = + "starkware.cairo.common.cairo_keccak.keccak.KECCAK_FULL_RATE_IN_BYTES"; +const KECCAK_FULL_RATE_IN_BYTES_BUILTIN_KECCAK: &str = "starkware.cairo.common.builtin_keccak.keccak.KECCAK_FULL_RATE_IN_BYTES"; + +const KECCAK_FULL_RATE_IN_BYTES: &str = "KECCAK_FULL_RATE_IN_BYTES"; + const KECCAK_STATE_SIZE_FELTS: &str = - "starkware.cairo.common.builtin_keccak.keccak.KECCAK_STATE_SIZE_FELTS"; + "starkware.cairo.common.cairo_keccak.keccak.KECCAK_STATE_SIZE_FELTS"; // Constants in package "starkware.cairo.common.cairo_keccak.packed_keccak". const BLOCK_SIZE: &str = "starkware.cairo.common.cairo_keccak.packed_keccak.BLOCK_SIZE"; @@ -106,7 +111,8 @@ pub fn compare_keccak_full_rate_in_bytes_nondet( let n_bytes = n_bytes.as_ref(); let keccak_full_rate_in_bytes = constants - .get(KECCAK_FULL_RATE_IN_BYTES) + .get(KECCAK_FULL_RATE_IN_BYTES_CAIRO_KECCAK) + .or(constants.get(KECCAK_FULL_RATE_IN_BYTES_BUILTIN_KECCAK)) .ok_or(HintError::MissingConstant(KECCAK_FULL_RATE_IN_BYTES))?; let value = Felt::new((n_bytes >= keccak_full_rate_in_bytes) as usize); insert_value_into_ap(vm, value) @@ -318,7 +324,7 @@ mod tests { ids_data, hint_code, exec_scopes_ref!(), - &[(KECCAK_FULL_RATE_IN_BYTES, Felt::new(136))] + &[(KECCAK_FULL_RATE_IN_BYTES_CAIRO_KECCAK, Felt::new(136))] .into_iter() .map(|(k, v)| (k.to_string(), v)) .collect() @@ -346,7 +352,7 @@ mod tests { ids_data, hint_code, exec_scopes_ref!(), - &[(KECCAK_FULL_RATE_IN_BYTES, Felt::new(136))] + &[(KECCAK_FULL_RATE_IN_BYTES_CAIRO_KECCAK, Felt::new(136))] .into_iter() .map(|(k, v)| (k.to_string(), v)) .collect() @@ -373,7 +379,7 @@ mod tests { ids_data, hint_code, exec_scopes_ref!(), - &[(KECCAK_FULL_RATE_IN_BYTES, Felt::new(136))] + &[(KECCAK_FULL_RATE_IN_BYTES_CAIRO_KECCAK, Felt::new(136))] .into_iter() .map(|(k, v)| (k.to_string(), v)) .collect() diff --git a/src/hint_processor/builtin_hint_processor/hint_code.rs b/src/hint_processor/builtin_hint_processor/hint_code.rs index 904822d0f5..a5304bd1e2 100644 --- a/src/hint_processor/builtin_hint_processor/hint_code.rs +++ b/src/hint_processor/builtin_hint_processor/hint_code.rs @@ -504,7 +504,7 @@ pub(crate) const COMPARE_BYTES_IN_WORD_NONDET: &str = pub(crate) const COMPARE_KECCAK_FULL_RATE_IN_BYTES_NONDET: &str = r#"memory[ap] = to_felt_or_relocatable(ids.n_bytes >= ids.KECCAK_FULL_RATE_IN_BYTES)"#; -pub(crate) const BLOCK_PERMUTATION: &str = r#"from starkware.cairo.common.cairo_keccak.keccak_utils import keccak_func +pub(crate) const BLOCK_PERMUTATION: &str = r#"from starkware.cairo.common.keccak_utils.keccak_utils import keccak_func _keccak_state_size_felts = int(ids.KECCAK_STATE_SIZE_FELTS) assert 0 <= _keccak_state_size_felts < 100 diff --git a/src/hint_processor/builtin_hint_processor/keccak_utils.rs b/src/hint_processor/builtin_hint_processor/keccak_utils.rs index 4de77e0b89..9a7d7e3ad2 100644 --- a/src/hint_processor/builtin_hint_processor/keccak_utils.rs +++ b/src/hint_processor/builtin_hint_processor/keccak_utils.rs @@ -15,7 +15,9 @@ use num_traits::{One, Signed, ToPrimitive}; use sha3::{Digest, Keccak256}; use std::{cmp, collections::HashMap, ops::Shl}; -use super::{cairo_keccak::keccak_hints::BYTES_IN_WORD, hint_utils::insert_value_from_var_name}; +use super::hint_utils::insert_value_from_var_name; + +const BYTES_IN_WORD: &str = "starkware.cairo.common.builtin_keccak.keccak.BYTES_IN_WORD"; /* Implements hint: %{ From fb71f7eb7d74cd83165d67b22633d0926bd9322e Mon Sep 17 00:00:00 2001 From: Federica Date: Wed, 8 Mar 2023 17:49:16 -0300 Subject: [PATCH 28/38] Add newline at end of file --- cairo_programs/keccak_uint256.cairo | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/cairo_programs/keccak_uint256.cairo b/cairo_programs/keccak_uint256.cairo index 4eec69933e..1dc51b3262 100644 --- a/cairo_programs/keccak_uint256.cairo +++ b/cairo_programs/keccak_uint256.cairo @@ -16,4 +16,4 @@ func main{range_check_ptr, bitwise_ptr: BitwiseBuiltin*, keccak_ptr: KeccakBuilt assert res.low = 13431206634823648732212765105043225161; return (); -} \ No newline at end of file +} From 9601af6b174b17f1dc82f632fcef70e72d4636e0 Mon Sep 17 00:00:00 2001 From: Federica Date: Wed, 8 Mar 2023 17:51:10 -0300 Subject: [PATCH 29/38] Clippy --- .../builtin_hint_processor/cairo_keccak/keccak_hints.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/hint_processor/builtin_hint_processor/cairo_keccak/keccak_hints.rs b/src/hint_processor/builtin_hint_processor/cairo_keccak/keccak_hints.rs index 510e58e956..4384692abb 100644 --- a/src/hint_processor/builtin_hint_processor/cairo_keccak/keccak_hints.rs +++ b/src/hint_processor/builtin_hint_processor/cairo_keccak/keccak_hints.rs @@ -112,7 +112,7 @@ pub fn compare_keccak_full_rate_in_bytes_nondet( let keccak_full_rate_in_bytes = constants .get(KECCAK_FULL_RATE_IN_BYTES_CAIRO_KECCAK) - .or(constants.get(KECCAK_FULL_RATE_IN_BYTES_BUILTIN_KECCAK)) + .or_else(|| constants.get(KECCAK_FULL_RATE_IN_BYTES_BUILTIN_KECCAK)) .ok_or(HintError::MissingConstant(KECCAK_FULL_RATE_IN_BYTES))?; let value = Felt::new((n_bytes >= keccak_full_rate_in_bytes) as usize); insert_value_into_ap(vm, value) From ac44d5af8abdd2ad46f31d926ed295824b86e9cd Mon Sep 17 00:00:00 2001 From: Federica Date: Wed, 8 Mar 2023 17:53:49 -0300 Subject: [PATCH 30/38] Clean imports --- .../builtin_hint_processor_definition.rs | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) diff --git a/src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs b/src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs index 703219c3ee..410536c58a 100644 --- a/src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs +++ b/src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs @@ -6,7 +6,7 @@ use crate::{ }, cairo_keccak::keccak_hints::{ block_permutation, cairo_keccak_finalize, compare_bytes_in_word_nondet, - keccak_write_args, + compare_keccak_full_rate_in_bytes_nondet, keccak_write_args, }, dict_hint_utils::{ default_dict_new, dict_new, dict_read, dict_squash_copy_dict, @@ -14,7 +14,10 @@ use crate::{ }, find_element_hint::{find_element, search_sorted_lower}, hint_code, - keccak_utils::{split_input, split_output, unsafe_keccak, unsafe_keccak_finalize}, + keccak_utils::{ + split_input, split_n_bytes, split_output, split_output_mid_low_high, unsafe_keccak, + unsafe_keccak_finalize, + }, math_utils::*, memcpy_hint_utils::{ add_segment, enter_scope, exit_scope, memcpy_continue_copying, memcpy_enter_scope, @@ -65,11 +68,6 @@ use std::{any::Any, collections::HashMap, rc::Rc}; #[cfg(feature = "skip_next_instruction_hint")] use crate::hint_processor::builtin_hint_processor::skip_next_instruction::skip_next_instruction; -use super::{ - cairo_keccak::keccak_hints::compare_keccak_full_rate_in_bytes_nondet, - keccak_utils::{split_n_bytes, split_output_mid_low_high}, -}; - pub struct HintProcessorData { pub code: String, pub ap_tracking: ApTracking, From bc614a0c068e9d4d70d1a7536f4ace76bc3d5278 Mon Sep 17 00:00:00 2001 From: Federica Date: Thu, 9 Mar 2023 10:46:34 -0300 Subject: [PATCH 31/38] Re-hide recursive layout --- cairo-vm-cli/src/main.rs | 4 +--- src/vm/runners/cairo_runner.rs | 1 - 2 files changed, 1 insertion(+), 4 deletions(-) diff --git a/cairo-vm-cli/src/main.rs b/cairo-vm-cli/src/main.rs index b3c428db00..f9b05f96db 100644 --- a/cairo-vm-cli/src/main.rs +++ b/cairo-vm-cli/src/main.rs @@ -41,9 +41,7 @@ struct Args { fn validate_layout(value: &str) -> Result<(), String> { match value { - "plain" | "small" | "dex" | "bitwise" | "perpetual_with_bitwise" | "all" | "recursive" => { - Ok(()) - } + "plain" | "small" | "dex" | "bitwise" | "perpetual_with_bitwise" | "all" => Ok(()), _ => Err(format!("{value} is not a valid layout")), } } diff --git a/src/vm/runners/cairo_runner.rs b/src/vm/runners/cairo_runner.rs index 099e7ccd4b..a05e085233 100644 --- a/src/vm/runners/cairo_runner.rs +++ b/src/vm/runners/cairo_runner.rs @@ -105,7 +105,6 @@ impl CairoRunner { "perpetual_with_bitwise" => CairoLayout::perpetual_with_bitwise_instance(), "bitwise" => CairoLayout::bitwise_instance(), "all" => CairoLayout::all_instance(), - "recursive" => CairoLayout::recursive_instance(), name => return Err(RunnerError::InvalidLayoutName(name.to_string())), }; Ok(CairoRunner { From dc93be149ec597eaf353d422e8db401bd80eb71c Mon Sep 17 00:00:00 2001 From: fmoletta <99273364+fmoletta@users.noreply.github.com> Date: Wed, 15 Mar 2023 10:36:35 -0300 Subject: [PATCH 32/38] Update src/hint_processor/builtin_hint_processor/keccak_utils.rs Co-authored-by: Mario Rugiero --- src/hint_processor/builtin_hint_processor/keccak_utils.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/hint_processor/builtin_hint_processor/keccak_utils.rs b/src/hint_processor/builtin_hint_processor/keccak_utils.rs index 5cc49923d0..91700707ad 100644 --- a/src/hint_processor/builtin_hint_processor/keccak_utils.rs +++ b/src/hint_processor/builtin_hint_processor/keccak_utils.rs @@ -198,7 +198,7 @@ pub fn split_output( let output_name = format!("output{}", num); let output_cow = get_integer_from_var_name(&output_name, vm, ids_data, ap_tracking)?; let output = output_cow.as_ref(); - let low = output & ((Felt::one() << 128_u32) - 1_u32); + let low = output & Felt::from(u128::MAX); let high = output >> 128; insert_value_from_var_name( &format!("output{}_high", num), From 3b56cfa674d5a80f36d4fd258e49f16397df6f7c Mon Sep 17 00:00:00 2001 From: Federica Date: Wed, 15 Mar 2023 11:28:30 -0300 Subject: [PATCH 33/38] Add suggested change + fix conflicts --- Makefile | 4 +- .../builtin_hint_processor/keccak_utils.rs | 3 +- src/tests/cairo_run_test.rs | 170 +++++++++--------- .../poseidon_instance_def.rs | 2 +- src/vm/errors/vm_exception.rs | 2 +- src/vm/runners/builtin_runner/ec_op.rs | 21 ++- tests/cairo_run_test.rs | 12 +- 7 files changed, 110 insertions(+), 104 deletions(-) diff --git a/Makefile b/Makefile index 19e017e3cd..5f07024d33 100644 --- a/Makefile +++ b/Makefile @@ -32,7 +32,7 @@ $(TEST_PROOF_DIR)/%.json: $(TEST_PROOF_DIR)/%.cairo cairo-compile --cairo_path="$(TEST_PROOF_DIR):$(PROOF_BENCH_DIR)" $< --output $@ --proof_mode $(TEST_PROOF_DIR)/%.rs.trace $(TEST_PROOF_DIR)/%.rs.memory: $(TEST_PROOF_DIR)/%.json $(RELBIN) - cargo llvm-cov run -p cairo-vm-cli --release --no-report -- --layout all --proof_mode $< --trace_file $@ --memory_file $(@D)/$(*F).rs.memory + cargo llvm-cov run -p cairo-vm-cli --release --no-report -- --layout all_cairo --proof_mode $< --trace_file $@ --memory_file $(@D)/$(*F).rs.memory $(TEST_PROOF_DIR)/%.trace $(TEST_PROOF_DIR)/%.memory: $(TEST_PROOF_DIR)/%.json cairo-run --layout all_cairo --proof_mode --program $< --trace_file $@ --memory_file $(@D)/$(*F).memory @@ -68,7 +68,7 @@ $(TEST_DIR)/%.json: $(TEST_DIR)/%.cairo cairo-compile --cairo_path="$(TEST_DIR):$(BENCH_DIR)" $< --output $@ $(TEST_DIR)/%.rs.trace $(TEST_DIR)/%.rs.memory: $(TEST_DIR)/%.json $(RELBIN) - cargo llvm-cov run -p cairo-vm-cli --release --no-report -- --layout all $< --trace_file $@ --memory_file $(@D)/$(*F).rs.memory + cargo llvm-cov run -p cairo-vm-cli --release --no-report -- --layout all_cairo $< --trace_file $@ --memory_file $(@D)/$(*F).rs.memory $(TEST_DIR)/%.trace $(TEST_DIR)/%.memory: $(TEST_DIR)/%.json cairo-run --layout all_cairo --program $< --trace_file $@ --memory_file $(@D)/$(*F).memory diff --git a/src/hint_processor/builtin_hint_processor/keccak_utils.rs b/src/hint_processor/builtin_hint_processor/keccak_utils.rs index 91700707ad..84a2b42d34 100644 --- a/src/hint_processor/builtin_hint_processor/keccak_utils.rs +++ b/src/hint_processor/builtin_hint_processor/keccak_utils.rs @@ -227,7 +227,8 @@ pub fn split_input( let inputs_ptr = get_ptr_from_var_name("inputs", vm, ids_data, ap_tracking)?; let binding = vm.get_integer((inputs_ptr + input_key)?)?; let input = binding.as_ref(); - let (high, low) = input.div_rem(&Felt::from(256_u64.pow(exponent))); + let low = input & ((Felt::one() << (8 * exponent)) - 1u32); + let high = input >> (8 * exponent); insert_value_from_var_name( &format!("high{}", input_key), high, diff --git a/src/tests/cairo_run_test.rs b/src/tests/cairo_run_test.rs index 8930d3c7aa..bed13dd3bd 100644 --- a/src/tests/cairo_run_test.rs +++ b/src/tests/cairo_run_test.rs @@ -14,7 +14,7 @@ fn fibonacci() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -30,7 +30,7 @@ fn array_sum() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -46,7 +46,7 @@ fn big_struct() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -62,7 +62,7 @@ fn call_function_assign_param_by_name() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -78,7 +78,7 @@ fn function_return() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -94,7 +94,7 @@ fn function_return_if_print() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -110,7 +110,7 @@ fn function_return_to_variable() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -126,7 +126,7 @@ fn if_and_prime() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -142,7 +142,7 @@ fn if_in_function() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -158,7 +158,7 @@ fn if_list() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -174,7 +174,7 @@ fn jmp() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -190,7 +190,7 @@ fn jmp_if_condition() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -206,7 +206,7 @@ fn pointers() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -222,7 +222,7 @@ fn print() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -238,7 +238,7 @@ fn program_return() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -254,7 +254,7 @@ fn reversed_register_instructions() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -270,7 +270,7 @@ fn simple_print() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -286,7 +286,7 @@ fn test_addition_if() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -302,7 +302,7 @@ fn test_reverse_if() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -318,7 +318,7 @@ fn test_subtraction_if() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -334,7 +334,7 @@ fn use_imported_module() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -350,7 +350,7 @@ fn bitwise_output() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -366,7 +366,7 @@ fn bitwise_recursion() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -382,7 +382,7 @@ fn integration() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -398,7 +398,7 @@ fn integration_with_alloc_locals() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -414,7 +414,7 @@ fn compare_arrays() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -430,7 +430,7 @@ fn compare_greater_array() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -446,7 +446,7 @@ fn compare_lesser_array() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -462,7 +462,7 @@ fn assert_le_felt_hint() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -478,7 +478,7 @@ fn assert_250_bit_element_array() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -494,7 +494,7 @@ fn abs_value_array() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -510,7 +510,7 @@ fn compare_different_arrays() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -526,7 +526,7 @@ fn assert_nn() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -542,7 +542,7 @@ fn sqrt() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -558,7 +558,7 @@ fn assert_not_zero() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -574,7 +574,7 @@ fn split_int() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -590,7 +590,7 @@ fn split_int_big() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -606,7 +606,7 @@ fn split_felt() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -622,7 +622,7 @@ fn math_cmp() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -638,7 +638,7 @@ fn unsigned_div_rem() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -654,7 +654,7 @@ fn signed_div_rem() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -670,7 +670,7 @@ fn assert_lt_felt() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -686,7 +686,7 @@ fn memcpy_test() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -702,7 +702,7 @@ fn memset() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -718,7 +718,7 @@ fn pow() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -734,7 +734,7 @@ fn dict() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -750,7 +750,7 @@ fn dict_update() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -766,7 +766,7 @@ fn uint256() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -782,7 +782,7 @@ fn find_element() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -798,7 +798,7 @@ fn search_sorted_lower() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -814,7 +814,7 @@ fn usort() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -830,7 +830,7 @@ fn squash_dict() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -846,7 +846,7 @@ fn dict_squash() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -862,7 +862,7 @@ fn set_add() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -878,7 +878,7 @@ fn secp() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -894,7 +894,7 @@ fn signature() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -910,7 +910,7 @@ fn secp_ec() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -926,7 +926,7 @@ fn blake2s_hello_world_hash() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -942,7 +942,7 @@ fn finalize_blake2s() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -958,7 +958,7 @@ fn unsafe_keccak() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -974,7 +974,7 @@ fn blake2s_felts() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -990,7 +990,7 @@ fn unsafe_keccak_finalize() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -1006,7 +1006,7 @@ fn keccak_add_uint256() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -1022,7 +1022,7 @@ fn keccak() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -1038,7 +1038,7 @@ fn keccak_copy_inputs() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -1054,7 +1054,7 @@ fn cairo_finalize_keccak() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -1070,7 +1070,7 @@ fn operations_with_data_structures() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -1086,7 +1086,7 @@ fn sha256() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -1102,7 +1102,7 @@ fn math_cmp_and_pow_integration_tests() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -1118,7 +1118,7 @@ fn uint256_integration_tests() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -1134,7 +1134,7 @@ fn set_integration_tests() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -1150,7 +1150,7 @@ fn memory_integration_tests() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -1166,7 +1166,7 @@ fn dict_integration_tests() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -1182,7 +1182,7 @@ fn secp_integration_tests() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -1198,7 +1198,7 @@ fn keccak_integration_tests() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -1214,7 +1214,7 @@ fn blake2s_integration_tests() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -1230,7 +1230,7 @@ fn relocate_segments() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -1246,7 +1246,7 @@ fn dict_store_cast_ptr() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -1262,7 +1262,7 @@ fn common_signature() { cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -1279,7 +1279,7 @@ fn bad_usort() { let res = cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -1300,7 +1300,7 @@ fn bad_dict_new() { let res = cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -1322,7 +1322,7 @@ fn bad_dict_update() { let res = cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -1343,7 +1343,7 @@ fn error_msg_attr() { let res = cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -1368,7 +1368,7 @@ fn error_msg_attr_tempvar() { let res = cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, @@ -1389,7 +1389,7 @@ fn error_msg_attr_struct() { let res = cairo_run::cairo_run( file, &CairoRunConfig { - layout: "all", + layout: "all_cairo", ..Default::default() }, &mut hint_executor, diff --git a/src/types/instance_definitions/poseidon_instance_def.rs b/src/types/instance_definitions/poseidon_instance_def.rs index 5230964859..775f46cc75 100644 --- a/src/types/instance_definitions/poseidon_instance_def.rs +++ b/src/types/instance_definitions/poseidon_instance_def.rs @@ -23,7 +23,7 @@ mod tests { #[test] fn test_new() { let builtin_instance = PoseidonInstanceDef { ratio: 8 }; - assert_eq!(PoseidonInstanceDef::_new(8), builtin_instance); + assert_eq!(PoseidonInstanceDef::new(8), builtin_instance); } #[test] diff --git a/src/vm/errors/vm_exception.rs b/src/vm/errors/vm_exception.rs index 0480fc6ae2..e098c85f3d 100644 --- a/src/vm/errors/vm_exception.rs +++ b/src/vm/errors/vm_exception.rs @@ -680,7 +680,7 @@ cairo_programs/bad_programs/bad_usort.cairo:64:5: (pc=0:60) "; let mut hint_processor = BuiltinHintProcessor::new_empty(); - let mut cairo_runner = cairo_runner!(program, "all", false); + let mut cairo_runner = cairo_runner!(program, "all_cairo", false); let mut vm = vm!(); let end = cairo_runner.initialize(&mut vm).unwrap(); diff --git a/src/vm/runners/builtin_runner/ec_op.rs b/src/vm/runners/builtin_runner/ec_op.rs index b1121f701d..242a24d003 100644 --- a/src/vm/runners/builtin_runner/ec_op.rs +++ b/src/vm/runners/builtin_runner/ec_op.rs @@ -1,8 +1,5 @@ -use crate::stdlib::{borrow::Cow, prelude::*}; -use std::cell::RefCell; -use std::collections::HashMap; - use crate::math_utils::{ec_add, ec_double, safe_div_usize}; +use crate::stdlib::{borrow::Cow, prelude::*}; use crate::types::instance_definitions::ec_op_instance_def::{ EcOpInstanceDef, CELLS_PER_EC_OP, INPUT_CELLS_PER_EC_OP, }; @@ -16,6 +13,8 @@ use felt::Felt; use num_bigint::{BigInt, ToBigInt}; use num_integer::{div_ceil, Integer}; use num_traits::{Num, One, Pow, Zero}; +use std::cell::RefCell; +use std::collections::HashMap; use super::EC_OP_BUILTIN_NAME; @@ -347,6 +346,7 @@ mod tests { use crate::stdlib::collections::HashMap; use crate::types::program::Program; use crate::utils::{test_utils::*, CAIRO_PRIME}; + use crate::vm::errors::cairo_run_errors::CairoRunError; use crate::vm::errors::vm_errors::VirtualMachineError; use crate::vm::runners::builtin_runner::HASH_BUILTIN_NAME; use crate::vm::runners::cairo_runner::CairoRunner; @@ -1036,7 +1036,7 @@ mod tests { #[test] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn catch_point_same_x() { - let program = Path::new("cairo_programs/bad_programs/ec_op_same_x.json"); + let program = include_bytes!("../../../../cairo_programs/bad_programs/ec_op_same_x.json"); let cairo_run_config = crate::cairo_run::CairoRunConfig { layout: "all_cairo", ..crate::cairo_run::CairoRunConfig::default() @@ -1049,7 +1049,9 @@ mod tests { assert!(result.is_err()); // We need to check this way because CairoRunError doens't implement PartialEq match result { - Err(VirtualMachineError::RunnerError(RunnerError::EcOpSameXCoordinate(_))) => {} + Err(CairoRunError::VirtualMachine(VirtualMachineError::RunnerError( + RunnerError::EcOpSameXCoordinate(_), + ))) => {} Err(_) => panic!("Wrong error returned, expected RunnerError::EcOpSameXCoordinate"), Ok(_) => panic!("Expected run to fail"), } @@ -1058,7 +1060,8 @@ mod tests { #[test] #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)] fn catch_point_not_in_curve() { - let program = Path::new("cairo_programs/bad_programs/ec_op_not_in_curve.json"); + let program = + include_bytes!("../../../../cairo_programs/bad_programs/ec_op_not_in_curve.json"); let cairo_run_config = crate::cairo_run::CairoRunConfig { layout: "all_cairo", ..crate::cairo_run::CairoRunConfig::default() @@ -1072,7 +1075,9 @@ mod tests { // We need to check this way because CairoRunError doens't implement PartialEq match result { - Err(VirtualMachineError::RunnerError(RunnerError::PointNotOnCurve(_))) => {} + Err(CairoRunError::VirtualMachine(VirtualMachineError::RunnerError( + RunnerError::PointNotOnCurve(_), + ))) => {} Err(_) => panic!("Wrong error returned, expected RunnerError::EcOpSameXCoordinate"), Ok(_) => panic!("Expected run to fail"), } diff --git a/tests/cairo_run_test.rs b/tests/cairo_run_test.rs index 5894206c49..460509c1d4 100644 --- a/tests/cairo_run_test.rs +++ b/tests/cairo_run_test.rs @@ -1414,7 +1414,7 @@ fn cairo_run_verify_signature_hint() { fn cairo_run_poseidon_builtin() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { - layout: "all", + layout: "all_cairo", ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( @@ -1430,7 +1430,7 @@ fn cairo_run_poseidon_builtin() { fn cairo_run_poseidon_hash() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { - layout: "all", + layout: "all_cairo", ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( @@ -1445,11 +1445,11 @@ fn cairo_run_poseidon_hash() { fn cairo_run_keccak_builtin() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { - layout: "recursive", + layout: "all_cairo", ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("cairo_programs/keccak_builtin.json"), + include_bytes!("../cairo_programs/keccak_builtin.json"), &cairo_run_config, &mut hint_executor, ) @@ -1460,11 +1460,11 @@ fn cairo_run_keccak_builtin() { fn cairo_run_keccak_uint256() { let mut hint_executor = BuiltinHintProcessor::new_empty(); let cairo_run_config = cairo_run::CairoRunConfig { - layout: "recursive", + layout: "all_cairo", ..cairo_vm::cairo_run::CairoRunConfig::default() }; cairo_run::cairo_run( - include_bytes!("cairo_programs/keccak_uint256.json"), + include_bytes!("../cairo_programs/keccak_uint256.json"), &cairo_run_config, &mut hint_executor, ) From b1576c3bb774feab35ffede0991cab129a5d80a7 Mon Sep 17 00:00:00 2001 From: fmoletta <99273364+fmoletta@users.noreply.github.com> Date: Wed, 15 Mar 2023 11:32:52 -0300 Subject: [PATCH 34/38] Update src/hint_processor/builtin_hint_processor/keccak_utils.rs Co-authored-by: Mario Rugiero --- src/hint_processor/builtin_hint_processor/keccak_utils.rs | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/hint_processor/builtin_hint_processor/keccak_utils.rs b/src/hint_processor/builtin_hint_processor/keccak_utils.rs index 84a2b42d34..38f97b6153 100644 --- a/src/hint_processor/builtin_hint_processor/keccak_utils.rs +++ b/src/hint_processor/builtin_hint_processor/keccak_utils.rs @@ -265,8 +265,10 @@ pub fn split_output_mid_low_high( ) -> Result<(), HintError> { let binding = get_integer_from_var_name("output1", vm, ids_data, ap_tracking)?; let output1 = binding.as_ref(); - let (tmp, output1_low) = output1.div_rem(&Felt::from(256_u64.pow(7))); - let (output1_high, output1_mid) = tmp.div_rem(&Felt::one().shl(128_u32)); + let output1_low = output1 & Felt::from((1u64 << (8 * 7)) - 1u64); + let tmp = output1 >> (8 * 7); + let output1_high = tmp >> 128; + let output1_mid = tmp & Felt::from(u128::MAX); insert_value_from_var_name("output1_high", output1_high, vm, ids_data, ap_tracking)?; insert_value_from_var_name("output1_mid", output1_mid, vm, ids_data, ap_tracking)?; insert_value_from_var_name("output1_low", output1_low, vm, ids_data, ap_tracking) From f8b2d11622a355590c84c2f73d17ee4fafd36d14 Mon Sep 17 00:00:00 2001 From: Federica Date: Wed, 15 Mar 2023 11:34:02 -0300 Subject: [PATCH 35/38] Fix --- src/hint_processor/builtin_hint_processor/keccak_utils.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/hint_processor/builtin_hint_processor/keccak_utils.rs b/src/hint_processor/builtin_hint_processor/keccak_utils.rs index 38f97b6153..0ee10d0d7d 100644 --- a/src/hint_processor/builtin_hint_processor/keccak_utils.rs +++ b/src/hint_processor/builtin_hint_processor/keccak_utils.rs @@ -267,8 +267,8 @@ pub fn split_output_mid_low_high( let output1 = binding.as_ref(); let output1_low = output1 & Felt::from((1u64 << (8 * 7)) - 1u64); let tmp = output1 >> (8 * 7); - let output1_high = tmp >> 128; - let output1_mid = tmp & Felt::from(u128::MAX); + let output1_high = &tmp >> 128; + let output1_mid = tmp & &Felt::from(u128::MAX); insert_value_from_var_name("output1_high", output1_high, vm, ids_data, ap_tracking)?; insert_value_from_var_name("output1_mid", output1_mid, vm, ids_data, ap_tracking)?; insert_value_from_var_name("output1_low", output1_low, vm, ids_data, ap_tracking) From 292e3feae46c1ac4df3880a5c4ba96482c2304ef Mon Sep 17 00:00:00 2001 From: Federica Date: Wed, 15 Mar 2023 11:49:58 -0300 Subject: [PATCH 36/38] Use u64 in split_n_bytes hints --- .../builtin_hint_processor/keccak_utils.rs | 22 +++++++++++++++---- 1 file changed, 18 insertions(+), 4 deletions(-) diff --git a/src/hint_processor/builtin_hint_processor/keccak_utils.rs b/src/hint_processor/builtin_hint_processor/keccak_utils.rs index 0ee10d0d7d..158228fe15 100644 --- a/src/hint_processor/builtin_hint_processor/keccak_utils.rs +++ b/src/hint_processor/builtin_hint_processor/keccak_utils.rs @@ -1,5 +1,6 @@ use crate::stdlib::{cmp, collections::HashMap, ops::Shl, prelude::*}; +use crate::types::errors::math_errors::MathError; use crate::{ hint_processor::{ builtin_hint_processor::hint_utils::{ @@ -246,13 +247,26 @@ pub fn split_n_bytes( ap_tracking: &ApTracking, constants: &HashMap, ) -> Result<(), HintError> { - let n_bytes = get_integer_from_var_name("n_bytes", vm, ids_data, ap_tracking)?; + let n_bytes = + get_integer_from_var_name("n_bytes", vm, ids_data, ap_tracking).and_then(|x| { + x.to_u64() + .ok_or(HintError::Math(MathError::FeltToU64Conversion( + x.into_owned(), + ))) + })?; let bytes_in_word = constants .get(BYTES_IN_WORD) + .and_then(|x| x.to_u64()) .ok_or(HintError::MissingConstant(BYTES_IN_WORD))?; - let (high, low) = n_bytes.div_rem(bytes_in_word); - insert_value_from_var_name("n_words_to_copy", high, vm, ids_data, ap_tracking)?; - insert_value_from_var_name("n_bytes_left", low, vm, ids_data, ap_tracking) + let (high, low) = n_bytes.div_mod_floor(&bytes_in_word); + insert_value_from_var_name( + "n_words_to_copy", + Felt::from(high), + vm, + ids_data, + ap_tracking, + )?; + insert_value_from_var_name("n_bytes_left", Felt::from(low), vm, ids_data, ap_tracking) } // Implements hint: From b205cc767a9d31e1bd85bc8731ddfb5fd59741ee Mon Sep 17 00:00:00 2001 From: Federica Date: Wed, 15 Mar 2023 12:11:49 -0300 Subject: [PATCH 37/38] Use starknet_with_keccak layout when running cairo-lang --- Makefile | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Makefile b/Makefile index 5f07024d33..ad20407c48 100644 --- a/Makefile +++ b/Makefile @@ -35,7 +35,7 @@ $(TEST_PROOF_DIR)/%.rs.trace $(TEST_PROOF_DIR)/%.rs.memory: $(TEST_PROOF_DIR)/%. cargo llvm-cov run -p cairo-vm-cli --release --no-report -- --layout all_cairo --proof_mode $< --trace_file $@ --memory_file $(@D)/$(*F).rs.memory $(TEST_PROOF_DIR)/%.trace $(TEST_PROOF_DIR)/%.memory: $(TEST_PROOF_DIR)/%.json - cairo-run --layout all_cairo --proof_mode --program $< --trace_file $@ --memory_file $(@D)/$(*F).memory + cairo-run --layout starknet_with_keccak --proof_mode --program $< --trace_file $@ --memory_file $(@D)/$(*F).memory $(PROOF_BENCH_DIR)/%.json: $(PROOF_BENCH_DIR)/%.cairo cairo-compile --cairo_path="$(TEST_PROOF_DIR):$(PROOF_BENCH_DIR)" $< --output $@ --proof_mode @@ -71,7 +71,7 @@ $(TEST_DIR)/%.rs.trace $(TEST_DIR)/%.rs.memory: $(TEST_DIR)/%.json $(RELBIN) cargo llvm-cov run -p cairo-vm-cli --release --no-report -- --layout all_cairo $< --trace_file $@ --memory_file $(@D)/$(*F).rs.memory $(TEST_DIR)/%.trace $(TEST_DIR)/%.memory: $(TEST_DIR)/%.json - cairo-run --layout all_cairo --program $< --trace_file $@ --memory_file $(@D)/$(*F).memory + cairo-run --layout starknet_with_keccak --program $< --trace_file $@ --memory_file $(@D)/$(*F).memory $(BENCH_DIR)/%.json: $(BENCH_DIR)/%.cairo cairo-compile --cairo_path="$(TEST_DIR):$(BENCH_DIR)" $< --output $@ From 1bbc6af9be487d1927bde5102f294419e9094169 Mon Sep 17 00:00:00 2001 From: Federica Date: Wed, 15 Mar 2023 12:13:54 -0300 Subject: [PATCH 38/38] Fix relative path in compare_vm_state script --- src/tests/compare_vm_state.sh | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/tests/compare_vm_state.sh b/src/tests/compare_vm_state.sh index 5c15a37cf4..61a7d3032e 100755 --- a/src/tests/compare_vm_state.sh +++ b/src/tests/compare_vm_state.sh @@ -1,6 +1,6 @@ #!/usr/bin/env sh -tests_path="../cairo_programs" +tests_path="../../cairo_programs" exit_code=0 trace=false memory=false @@ -13,7 +13,7 @@ for i in $@; do ;; "memory") memory=true ;; - "proof_mode") tests_path="../cairo_programs/proof_programs" + "proof_mode") tests_path="../../cairo_programs/proof_programs" ;; *) ;;