Update layouts to cairo-lang 0.11 release

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 --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 --proof_mode --program $< --trace_file $@ --memory_file $(@D)/$(*F).memory
+	cairo-run --layout all_cairo --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 $< --trace_file $@ --memory_file $(@D)/$(*F).rs.memory
 
 $(TEST_DIR)/%.trace $(TEST_DIR)/%.memory: $(TEST_DIR)/%.json
-	cairo-run --layout all --program $< --trace_file $@ --memory_file $(@D)/$(*F).memory
+	cairo-run --layout all_cairo --program $< --trace_file $@ --memory_file $(@D)/$(*F).memory
 
 $(BENCH_DIR)/%.json: $(BENCH_DIR)/%.cairo
 	cairo-compile --cairo_path="$(TEST_DIR):$(BENCH_DIR)" $< --output $@

README.md

@@ -94,7 +94,7 @@ cairo-compile cairo_programs/abs_value_array.cairo --output cairo_programs/abs_v
 To run a compiled .json program through the VM, call the executable giving it the path and name of the file to be executed. For example: 
 
 ```bash 
-target/release/cairo-rs-run cairo_programs/abs_value_array_compiled.json --layout all
+target/release/cairo-rs-run cairo_programs/abs_value_array_compiled.json --layout all_cairo
 ```
 The flag `--layout` determines which builtins can be used. More info about layouts [here](https://www.cairo-lang.org/docs/how_cairo_works/builtins.html#layouts).
 
@@ -109,7 +109,7 @@ cargo build --release
 
 cairo-compile cairo_programs/abs_value_array.cairo --output cairo_programs/abs_value_array_compiled.json
 
-target/release/cairo-rs-run cairo_programs/abs_value_array_compiled.json --layout all
+target/release/cairo-rs-run cairo_programs/abs_value_array_compiled.json --layout all_cairo
 ```
 ### Using hints
 
@@ -133,7 +133,7 @@ let program =
 ```rust
 let mut vm = VirtualMachine::new(false);
 
-let mut cairo_runner = CairoRunner::new(&program, "all", false);
+let mut cairo_runner = CairoRunner::new(&program, "all_cairo", false);
 
 let mut hint_processor = BuiltinHintProcessor::new_empty();
 

bench/criterion_benchmark.rs

@@ -28,7 +28,7 @@ const BENCH_PATH: &str = "cairo_programs/benchmarks/";
 pub fn criterion_benchmarks(c: &mut Criterion) {
     let mut hint_executor = BuiltinHintProcessor::new_empty();
     let cairo_run_config = cairo_vm::cairo_run::CairoRunConfig {
-        layout: "all",
+        layout: "all_cairo",
         ..cairo_vm::cairo_run::CairoRunConfig::default()
     };
     for benchmark_name in build_bench_strings() {

bench/iai_benchmark.rs

@@ -12,7 +12,7 @@ macro_rules! iai_bench_expand_prog {
     ($val: ident) => {
         fn $val() -> Result<(CairoRunner, VirtualMachine), CairoRunError> {
             let cairo_run_config = cairo_vm::cairo_run::CairoRunConfig {
-                layout: "all",
+                layout: "all_cairo",
                 ..cairo_vm::cairo_run::CairoRunConfig::default()
             };
             let mut hint_executor = BuiltinHintProcessor::new_empty();

bench/run_benchmarks.sh

@@ -9,7 +9,7 @@ for file in $(ls $tests_path | grep .cairo | sed -E 's/\.cairo//'); do
     export PATH="$(pyenv root)/shims:$PATH"
 
     hyperfine \
-	    -n "Cairo VM (CPython)" "PYENV_VERSION=3.7.12 cairo-run --layout all --program $tests_path/$file.json" \
-	    -n "Cairo VM (PyPy)" "PYENV_VERSION=pypy3.7-7.3.9 cairo-run --layout all --program $tests_path/$file.json" \
-	    -n "cairo-rs (Rust)" "../target/release/cairo-rs-run $tests_path/$file.json --layout all"
+	    -n "Cairo VM (CPython)" "PYENV_VERSION=3.7.12 cairo-run --layout all_cairo --program $tests_path/$file.json" \
+	    -n "Cairo VM (PyPy)" "PYENV_VERSION=pypy3.7-7.3.9 cairo-run --layout all_cairo --program $tests_path/$file.json" \
+	    -n "cairo-rs (Rust)" "../target/release/cairo-rs-run $tests_path/$file.json --layout all_cairo"
 done

cairo-vm-cli/src/main.rs

@@ -41,7 +41,14 @@ struct Args {
 
 fn validate_layout(value: &str) -> Result<(), String> {
     match value {
-        "plain" | "small" | "dex" | "bitwise" | "perpetual_with_bitwise" | "all" => Ok(()),
+        "plain"
+        | "small"
+        | "dex"
+        | "starknet"
+        | "starknet_with_keccak"
+        | "recursive_large_output"
+        | "all_cairo"
+        | "all_solidity" => Ok(()),
         _ => Err(format!("{value} is not a valid layout")),
     }
 }
@@ -153,9 +160,11 @@ mod tests {
             "plain",
             "small",
             "dex",
-            "bitwise",
-            "perpetual_with_bitwise",
-            "all",
+            "starknet",
+            "starknet_with_keccak",
+            "recursive_large_output",
+            "all_cairo",
+            "all_solidity",
         ];
 
         for layout in valid_layouts {

custom_hint_example/src/main.rs

@@ -41,7 +41,7 @@ fn main() {
         "main",
         false,
         false,
-        "all",
+        "all_cairo",
         false,
         &mut hint_processor,
     )

src/tests/bitwise_test.rs

@@ -23,7 +23,7 @@ fn bitwise_integration_test() {
     )
     .unwrap();
     let mut hint_processor = BuiltinHintProcessor::new_empty();
-    let mut cairo_runner = CairoRunner::new(&program, "all", false).unwrap();
+    let mut cairo_runner = CairoRunner::new(&program, "all_cairo", false).unwrap();
     let mut vm = VirtualMachine::new(true);
     let end = cairo_runner.initialize(&mut vm).unwrap();
     assert_matches!(

src/tests/pedersen_test.rs

@@ -21,7 +21,7 @@ fn pedersen_integration_test() {
     )
     .unwrap();
     let mut hint_processor = BuiltinHintProcessor::new_empty();
-    let mut cairo_runner = CairoRunner::new(&program, "all", false).unwrap();
+    let mut cairo_runner = CairoRunner::new(&program, "all_cairo", false).unwrap();
     let mut vm = VirtualMachine::new(true);
     let end = cairo_runner.initialize(&mut vm).unwrap();
     assert_matches!(

src/tests/skip_instruction_test.rs

@@ -22,7 +22,7 @@ fn skip_next_instruction_test() {
 
     let mut hint_processor = BuiltinHintProcessor::new_empty();
 
-    let mut cairo_runner = CairoRunner::new(&program, "all", false).unwrap();
+    let mut cairo_runner = CairoRunner::new(&program, "all_cairo", false).unwrap();
     let mut vm = VirtualMachine::new(false);
     let end = cairo_runner.initialize(&mut vm).unwrap();
     assert_matches!(

src/tests/struct_test.rs

@@ -19,7 +19,7 @@ fn struct_integration_test() {
     )
     .unwrap();
     let mut hint_processor = BuiltinHintProcessor::new_empty();
-    let mut cairo_runner = CairoRunner::new(&program, "all", false).unwrap();
+    let mut cairo_runner = CairoRunner::new(&program, "all_cairo", false).unwrap();
     let mut vm = VirtualMachine::new(true);
     let end = cairo_runner.initialize(&mut vm).unwrap();
 

src/types/instance_definitions/builtins_instance_def.rs

@@ -57,7 +57,20 @@ impl BuiltinsInstanceDef {
         }
     }
 
-    pub(crate) fn perpetual_with_bitwise() -> BuiltinsInstanceDef {
+    pub(crate) fn recursive() -> BuiltinsInstanceDef {
+        BuiltinsInstanceDef {
+            output: true,
+            pedersen: Some(PedersenInstanceDef::new(128, 1)),
+            range_check: Some(RangeCheckInstanceDef::default()),
+            ecdsa: None,
+            bitwise: Some(BitwiseInstanceDef::new(8)),
+            ec_op: None,
+            keccak: None,
+            poseidon: None,
+        }
+    }
+
+    pub(crate) fn starknet() -> BuiltinsInstanceDef {
         BuiltinsInstanceDef {
             output: true,
             pedersen: Some(PedersenInstanceDef::new(32, 1)),
@@ -66,37 +79,50 @@ impl BuiltinsInstanceDef {
             bitwise: Some(BitwiseInstanceDef::new(64)),
             ec_op: Some(EcOpInstanceDef::new(1024)),
             keccak: None,
-            poseidon: None,
+            poseidon: Some(PoseidonInstanceDef::default()),
         }
     }
 
-    pub(crate) fn bitwise() -> BuiltinsInstanceDef {
+    pub(crate) fn starknet_with_keccak() -> BuiltinsInstanceDef {
         BuiltinsInstanceDef {
             output: true,
-            pedersen: Some(PedersenInstanceDef::new(256, 1)),
+            pedersen: Some(PedersenInstanceDef::new(32, 1)),
+            range_check: Some(RangeCheckInstanceDef::new(16, 8)),
+            ecdsa: Some(EcdsaInstanceDef::new(2048)),
+            bitwise: Some(BitwiseInstanceDef::new(64)),
+            ec_op: Some(EcOpInstanceDef::new(1024)),
+            keccak: Some(KeccakInstanceDef::new(2048, vec![200; 8])),
+            poseidon: Some(PoseidonInstanceDef::default()),
+        }
+    }
+
+    pub(crate) fn recursive_large_output() -> BuiltinsInstanceDef {
+        BuiltinsInstanceDef {
+            output: true,
+            pedersen: Some(PedersenInstanceDef::new(32, 1)),
             range_check: Some(RangeCheckInstanceDef::default()),
-            ecdsa: Some(EcdsaInstanceDef::new(1024)),
+            ecdsa: None,
             bitwise: Some(BitwiseInstanceDef::new(8)),
             ec_op: None,
             keccak: None,
             poseidon: None,
         }
     }
 
-    pub(crate) fn recursive() -> BuiltinsInstanceDef {
+    pub(crate) fn all_cairo() -> BuiltinsInstanceDef {
         BuiltinsInstanceDef {
             output: true,
             pedersen: Some(PedersenInstanceDef::new(256, 1)),
             range_check: Some(RangeCheckInstanceDef::default()),
-            ecdsa: None,
+            ecdsa: Some(EcdsaInstanceDef::new(2048)),
             bitwise: Some(BitwiseInstanceDef::new(16)),
-            ec_op: None,
+            ec_op: Some(EcOpInstanceDef::new(1024)),
             keccak: Some(KeccakInstanceDef::new(2048, vec![200; 8])),
-            poseidon: None,
+            poseidon: Some(PoseidonInstanceDef::new(256)),
         }
     }
 
-    pub(crate) fn all() -> BuiltinsInstanceDef {
+    pub(crate) fn all_solidity() -> BuiltinsInstanceDef {
         BuiltinsInstanceDef {
             output: true,
             pedersen: Some(PedersenInstanceDef::default()),
@@ -105,7 +131,7 @@ impl BuiltinsInstanceDef {
             bitwise: Some(BitwiseInstanceDef::default()),
             ec_op: Some(EcOpInstanceDef::default()),
             keccak: None,
-            poseidon: Some(PoseidonInstanceDef::default()), // Added for testing
+            poseidon: None,
         }
     }
 }
@@ -127,6 +153,8 @@ mod tests {
         assert!(builtins.ecdsa.is_none());
         assert!(builtins.bitwise.is_none());
         assert!(builtins.ec_op.is_none());
+        assert!(builtins.keccak.is_none());
+        assert!(builtins.poseidon.is_none());
     }
 
     #[test]
@@ -139,6 +167,8 @@ mod tests {
         assert!(builtins.ecdsa.is_some());
         assert!(builtins.bitwise.is_none());
         assert!(builtins.ec_op.is_none());
+        assert!(builtins.keccak.is_none());
+        assert!(builtins.poseidon.is_none());
     }
 
     #[test]
@@ -151,53 +181,86 @@ mod tests {
         assert!(builtins.ecdsa.is_some());
         assert!(builtins.bitwise.is_none());
         assert!(builtins.ec_op.is_none());
+        assert!(builtins.keccak.is_none());
+        assert!(builtins.poseidon.is_none());
     }
 
     #[test]
     #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
-    fn get_builtins_perpetual_with_bitwise() {
-        let builtins = BuiltinsInstanceDef::perpetual_with_bitwise();
+    fn get_builtins_recursive() {
+        let builtins = BuiltinsInstanceDef::recursive();
+        assert!(builtins.output);
+        assert!(builtins.pedersen.is_some());
+        assert!(builtins.range_check.is_some());
+        assert!(builtins.ecdsa.is_none());
+        assert!(builtins.bitwise.is_some());
+        assert!(builtins.ec_op.is_none());
+        assert!(builtins.keccak.is_none());
+        assert!(builtins.poseidon.is_none());
+    }
+
+    #[test]
+    fn get_builtins_starknet() {
+        let builtins = BuiltinsInstanceDef::starknet();
         assert!(builtins.output);
         assert!(builtins.pedersen.is_some());
         assert!(builtins.range_check.is_some());
         assert!(builtins.ecdsa.is_some());
         assert!(builtins.bitwise.is_some());
         assert!(builtins.ec_op.is_some());
+        assert!(builtins.keccak.is_none());
+        assert!(builtins.poseidon.is_some());
     }
 
     #[test]
-    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
-    fn get_builtins_bitwise() {
-        let builtins = BuiltinsInstanceDef::bitwise();
+    fn get_builtins_starknet_with_keccak() {
+        let builtins = BuiltinsInstanceDef::starknet_with_keccak();
         assert!(builtins.output);
         assert!(builtins.pedersen.is_some());
         assert!(builtins.range_check.is_some());
         assert!(builtins.ecdsa.is_some());
         assert!(builtins.bitwise.is_some());
-        assert!(builtins.ec_op.is_none());
+        assert!(builtins.ec_op.is_some());
+        assert!(builtins.keccak.is_some());
+        assert!(builtins.poseidon.is_some());
     }
 
     #[test]
-    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
-    fn get_builtins_recursive() {
-        let builtins = BuiltinsInstanceDef::recursive();
+    fn get_builtins_recursive_large_output() {
+        let builtins = BuiltinsInstanceDef::recursive_large_output();
         assert!(builtins.output);
         assert!(builtins.pedersen.is_some());
         assert!(builtins.range_check.is_some());
         assert!(builtins.ecdsa.is_none());
         assert!(builtins.bitwise.is_some());
         assert!(builtins.ec_op.is_none());
+        assert!(builtins.keccak.is_none());
+        assert!(builtins.poseidon.is_none());
     }
 
     #[test]
-    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
-    fn get_builtins_all() {
-        let builtins = BuiltinsInstanceDef::all();
+    fn get_builtins_all_cairo() {
+        let builtins = BuiltinsInstanceDef::all_cairo();
+        assert!(builtins.output);
+        assert!(builtins.pedersen.is_some());
+        assert!(builtins.range_check.is_some());
+        assert!(builtins.ecdsa.is_some());
+        assert!(builtins.bitwise.is_some());
+        assert!(builtins.ec_op.is_some());
+        assert!(builtins.keccak.is_some());
+        assert!(builtins.poseidon.is_some());
+    }
+
+    #[test]
+    fn get_builtins_all_solidity() {
+        let builtins = BuiltinsInstanceDef::all_solidity();
         assert!(builtins.output);
         assert!(builtins.pedersen.is_some());
         assert!(builtins.range_check.is_some());
         assert!(builtins.ecdsa.is_some());
         assert!(builtins.bitwise.is_some());
         assert!(builtins.ec_op.is_some());
+        assert!(builtins.keccak.is_none());
+        assert!(builtins.poseidon.is_none());
     }
 }

src/types/instance_definitions/poseidon_instance_def.rs

@@ -11,7 +11,7 @@ impl PoseidonInstanceDef {
         PoseidonInstanceDef { ratio: 32 }
     }
 
-    pub(crate) fn _new(ratio: u32) -> Self {
+    pub(crate) fn new(ratio: u32) -> Self {
         PoseidonInstanceDef { ratio }
     }
 }