Add dynamic layout

cairo-vm-cli/src/main.rs

@@ -41,7 +41,9 @@ 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" | "dynamic" => {
+            Ok(())
+        }
         _ => Err(format!("{value} is not a valid layout")),
     }
 }

src/types/instance_definitions/bitwise_instance_def.rs

@@ -3,19 +3,19 @@ pub(crate) const INPUT_CELLS_PER_BITWISE: u32 = 2;
 
 #[derive(Clone, Debug, PartialEq)]
 pub(crate) struct BitwiseInstanceDef {
-    pub(crate) ratio: u32,
+    pub(crate) ratio: Option<u32>,
     pub(crate) total_n_bits: u32,
 }
 
 impl BitwiseInstanceDef {
     pub(crate) fn default() -> Self {
         BitwiseInstanceDef {
-            ratio: 256,
+            ratio: Some(256),
             total_n_bits: 251,
         }
     }
 
-    pub(crate) fn new(ratio: u32) -> Self {
+    pub(crate) fn new(ratio: Option<u32>) -> Self {
         BitwiseInstanceDef {
             ratio,
             total_n_bits: 251,
@@ -56,17 +56,17 @@ mod tests {
     #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
     fn test_new() {
         let builtin_instance = BitwiseInstanceDef {
-            ratio: 8,
+            ratio: Some(8),
             total_n_bits: 251,
         };
-        assert_eq!(BitwiseInstanceDef::new(8), builtin_instance);
+        assert_eq!(BitwiseInstanceDef::new(Some(8)), builtin_instance);
     }
 
     #[test]
     #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
     fn test_default() {
         let builtin_instance = BitwiseInstanceDef {
-            ratio: 256,
+            ratio: Some(256),
             total_n_bits: 251,
         };
         assert_eq!(BitwiseInstanceDef::default(), builtin_instance);

src/types/instance_definitions/builtins_instance_def.rs

@@ -60,11 +60,11 @@ impl BuiltinsInstanceDef {
     pub(crate) fn perpetual_with_bitwise() -> BuiltinsInstanceDef {
         BuiltinsInstanceDef {
             output: true,
-            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)),
+            pedersen: Some(PedersenInstanceDef::new(Some(32), 1)),
+            range_check: Some(RangeCheckInstanceDef::new(Some(16), 8)),
+            ecdsa: Some(EcdsaInstanceDef::new(Some(2048))),
+            bitwise: Some(BitwiseInstanceDef::new(Some(64))),
+            ec_op: Some(EcOpInstanceDef::new(Some(1024))),
             keccak: None,
             poseidon: None,
         }
@@ -73,10 +73,10 @@ impl BuiltinsInstanceDef {
     pub(crate) fn bitwise() -> BuiltinsInstanceDef {
         BuiltinsInstanceDef {
             output: true,
-            pedersen: Some(PedersenInstanceDef::new(256, 1)),
+            pedersen: Some(PedersenInstanceDef::new(Some(256), 1)),
             range_check: Some(RangeCheckInstanceDef::default()),
-            ecdsa: Some(EcdsaInstanceDef::new(1024)),
-            bitwise: Some(BitwiseInstanceDef::new(8)),
+            ecdsa: Some(EcdsaInstanceDef::new(Some(1024))),
+            bitwise: Some(BitwiseInstanceDef::new(Some(8))),
             ec_op: None,
             keccak: None,
             poseidon: None,
@@ -86,12 +86,12 @@ impl BuiltinsInstanceDef {
     pub(crate) fn recursive() -> BuiltinsInstanceDef {
         BuiltinsInstanceDef {
             output: true,
-            pedersen: Some(PedersenInstanceDef::new(256, 1)),
+            pedersen: Some(PedersenInstanceDef::new(Some(256), 1)),
             range_check: Some(RangeCheckInstanceDef::default()),
             ecdsa: None,
-            bitwise: Some(BitwiseInstanceDef::new(16)),
+            bitwise: Some(BitwiseInstanceDef::new(Some(16))),
             ec_op: None,
-            keccak: Some(KeccakInstanceDef::new(2048, vec![200; 8])),
+            keccak: Some(KeccakInstanceDef::new(Some(2048), vec![200; 8])),
             poseidon: None,
         }
     }
@@ -108,6 +108,19 @@ impl BuiltinsInstanceDef {
             poseidon: Some(PoseidonInstanceDef::default()), // Added for testing
         }
     }
+
+    pub(crate) fn dynamic() -> BuiltinsInstanceDef {
+        BuiltinsInstanceDef {
+            output: true,
+            pedersen: Some(PedersenInstanceDef::new(None, 4)),
+            range_check: Some(RangeCheckInstanceDef::new(None, 8)),
+            ecdsa: Some(EcdsaInstanceDef::new(None)),
+            bitwise: Some(BitwiseInstanceDef::new(None)),
+            ec_op: Some(EcOpInstanceDef::new(None)),
+            keccak: None,
+            poseidon: None,
+        }
+    }
 }
 
 #[cfg(test)]

src/types/instance_definitions/ec_op_instance_def.rs

@@ -3,21 +3,21 @@ pub(crate) const INPUT_CELLS_PER_EC_OP: u32 = 5;
 
 #[derive(Clone, Debug, PartialEq)]
 pub(crate) struct EcOpInstanceDef {
-    pub(crate) ratio: u32,
+    pub(crate) ratio: Option<u32>,
     pub(crate) scalar_height: u32,
     pub(crate) _scalar_bits: u32,
 }
 
 impl EcOpInstanceDef {
     pub(crate) fn default() -> Self {
         EcOpInstanceDef {
-            ratio: 256,
+            ratio: Some(256),
             scalar_height: 256,
             _scalar_bits: 252,
         }
     }
 
-    pub(crate) fn new(ratio: u32) -> Self {
+    pub(crate) fn new(ratio: Option<u32>) -> Self {
         EcOpInstanceDef {
             ratio,
             scalar_height: 256,
@@ -59,18 +59,18 @@ mod tests {
     #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
     fn test_new() {
         let builtin_instance = EcOpInstanceDef {
-            ratio: 8,
+            ratio: Some(8),
             scalar_height: 256,
             _scalar_bits: 252,
         };
-        assert_eq!(EcOpInstanceDef::new(8), builtin_instance);
+        assert_eq!(EcOpInstanceDef::new(Some(8)), builtin_instance);
     }
 
     #[test]
     #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
     fn test_default() {
         let builtin_instance = EcOpInstanceDef {
-            ratio: 256,
+            ratio: Some(256),
             scalar_height: 256,
             _scalar_bits: 252,
         };

src/types/instance_definitions/ecdsa_instance_def.rs

@@ -3,7 +3,7 @@ pub(crate) const _INPUTCELLS_PER_SIGNATURE: u32 = 2;
 
 #[derive(Debug, PartialEq)]
 pub(crate) struct EcdsaInstanceDef {
-    pub(crate) ratio: u32,
+    pub(crate) ratio: Option<u32>,
     pub(crate) _repetitions: u32,
     pub(crate) _height: u32,
     pub(crate) _n_hash_bits: u32,
@@ -12,14 +12,14 @@ pub(crate) struct EcdsaInstanceDef {
 impl EcdsaInstanceDef {
     pub(crate) fn default() -> Self {
         EcdsaInstanceDef {
-            ratio: 512,
+            ratio: Some(512),
             _repetitions: 1,
             _height: 256,
             _n_hash_bits: 251,
         }
     }
 
-    pub(crate) fn new(ratio: u32) -> Self {
+    pub(crate) fn new(ratio: Option<u32>) -> Self {
         EcdsaInstanceDef {
             ratio,
             _repetitions: 1,
@@ -62,19 +62,19 @@ mod tests {
     #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
     fn test_new() {
         let builtin_instance = EcdsaInstanceDef {
-            ratio: 8,
+            ratio: Some(8),
             _repetitions: 1,
             _height: 256,
             _n_hash_bits: 251,
         };
-        assert_eq!(EcdsaInstanceDef::new(8), builtin_instance);
+        assert_eq!(EcdsaInstanceDef::new(Some(8)), builtin_instance);
     }
 
     #[test]
     #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
     fn test_default() {
         let builtin_instance = EcdsaInstanceDef {
-            ratio: 512,
+            ratio: Some(512),
             _repetitions: 1,
             _height: 256,
             _n_hash_bits: 251,

src/types/instance_definitions/keccak_instance_def.rs

@@ -2,26 +2,26 @@ use crate::stdlib::prelude::*;
 
 #[derive(Clone, Debug, PartialEq)]
 pub(crate) struct KeccakInstanceDef {
-    pub(crate) _ratio: u32,
+    pub(crate) ratio: Option<u32>,
     pub(crate) _state_rep: Vec<u32>,
     pub(crate) _instance_per_component: u32,
 }
 
 impl Default for KeccakInstanceDef {
     fn default() -> Self {
         Self {
-            // _ratio should be equal to 2 ** 11 -> 2048
-            _ratio: 2048,
+            // ratio should be equal to 2 ** 11 -> 2048
+            ratio: Some(2048),
             _state_rep: vec![200; 8],
             _instance_per_component: 16,
         }
     }
 }
 
 impl KeccakInstanceDef {
-    pub(crate) fn new(_ratio: u32, _state_rep: Vec<u32>) -> Self {
+    pub(crate) fn new(ratio: Option<u32>, _state_rep: Vec<u32>) -> Self {
         Self {
-            _ratio,
+            ratio,
             _state_rep,
             ..Default::default()
         }
@@ -61,18 +61,21 @@ mod tests {
     #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
     fn test_new() {
         let builtin_instance = KeccakInstanceDef {
-            _ratio: 2048,
+            ratio: Some(2048),
             _state_rep: vec![200; 8],
             _instance_per_component: 16,
         };
-        assert_eq!(KeccakInstanceDef::new(2048, vec![200; 8]), builtin_instance);
+        assert_eq!(
+            KeccakInstanceDef::new(Some(2048), vec![200; 8]),
+            builtin_instance
+        );
     }
 
     #[test]
     #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
     fn test_default() {
         let builtin_instance = KeccakInstanceDef {
-            _ratio: 2048,
+            ratio: Some(2048),
             _state_rep: vec![200; 8],
             _instance_per_component: 16,
         };

src/types/instance_definitions/pedersen_instance_def.rs

@@ -5,7 +5,7 @@ pub(crate) const INPUT_CELLS_PER_HASH: u32 = 2;
 
 #[derive(Debug, PartialEq)]
 pub(crate) struct PedersenInstanceDef {
-    pub(crate) ratio: u32,
+    pub(crate) ratio: Option<u32>,
     pub(crate) _repetitions: u32,
     pub(crate) _element_height: u32,
     pub(crate) _element_bits: u32,
@@ -16,7 +16,7 @@ pub(crate) struct PedersenInstanceDef {
 impl PedersenInstanceDef {
     pub(crate) fn default() -> Self {
         PedersenInstanceDef {
-            ratio: 8,
+            ratio: Some(8),
             _repetitions: 4,
             _element_height: 256,
             _element_bits: 252,
@@ -25,7 +25,7 @@ impl PedersenInstanceDef {
         }
     }
 
-    pub(crate) fn new(ratio: u32, _repetitions: u32) -> Self {
+    pub(crate) fn new(ratio: Option<u32>, _repetitions: u32) -> Self {
         PedersenInstanceDef {
             ratio,
             _repetitions,
@@ -70,21 +70,21 @@ mod tests {
     #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
     fn test_new() {
         let builtin_instance = PedersenInstanceDef {
-            ratio: 10,
+            ratio: Some(10),
             _repetitions: 2,
             _element_height: 256,
             _element_bits: 252,
             _n_inputs: 2,
             _hash_limit: BigInt::new(Sign::Plus, vec![1, 0, 0, 0, 0, 0, 17, 134217728]),
         };
-        assert_eq!(PedersenInstanceDef::new(10, 2), builtin_instance);
+        assert_eq!(PedersenInstanceDef::new(Some(10), 2), builtin_instance);
     }
 
     #[test]
     #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
     fn test_default() {
         let builtin_instance = PedersenInstanceDef {
-            ratio: 8,
+            ratio: Some(8),
             _repetitions: 4,
             _element_height: 256,
             _element_bits: 252,

src/types/instance_definitions/poseidon_instance_def.rs

@@ -3,15 +3,15 @@ pub(crate) const INPUT_CELLS_PER_POSEIDON: u32 = 3;
 
 #[derive(Clone, Debug, PartialEq)]
 pub(crate) struct PoseidonInstanceDef {
-    pub(crate) ratio: u32,
+    pub(crate) ratio: Option<u32>,
 }
 
 impl PoseidonInstanceDef {
     pub(crate) fn default() -> Self {
-        PoseidonInstanceDef { ratio: 32 }
+        PoseidonInstanceDef { ratio: Some(32) }
     }
 
-    pub(crate) fn _new(ratio: u32) -> Self {
+    pub(crate) fn _new(ratio: Option<u32>) -> Self {
         PoseidonInstanceDef { ratio }
     }
 }
@@ -22,13 +22,13 @@ mod tests {
 
     #[test]
     fn test_new() {
-        let builtin_instance = PoseidonInstanceDef { ratio: 8 };
-        assert_eq!(PoseidonInstanceDef::_new(8), builtin_instance);
+        let builtin_instance = PoseidonInstanceDef { ratio: Some(8) };
+        assert_eq!(PoseidonInstanceDef::_new(Some(8)), builtin_instance);
     }
 
     #[test]
     fn test_default() {
-        let builtin_instance = PoseidonInstanceDef { ratio: 32 };
+        let builtin_instance = PoseidonInstanceDef { ratio: Some(32) };
         assert_eq!(PoseidonInstanceDef::default(), builtin_instance);
     }
 }