feat: post compilation size limit validation

config/mempool/default_config.json

@@ -1,5 +1,10 @@
 {
-  "compiler_config.max_bytecode_size": {
+  "compiler_config.post_compilation_config.max_raw_casm_class_size": {
+    "description": "Limitation of contract class object size.",
+    "privacy": "Public",
+    "value": 4089446
+  },
+  "compiler_config.sierra_to_casm_compiler_config.max_bytecode_size": {
     "description": "Limitation of contract bytecode size.",
     "privacy": "Public",
     "value": 81920

crates/gateway/src/compilation.rs

@@ -6,10 +6,10 @@ use cairo_lang_starknet_classes::contract_class::ContractClass as CairoLangContr
 use starknet_api::core::CompiledClassHash;
 use starknet_api::rpc_transaction::RpcDeclareTransaction;
 use starknet_sierra_compile::cairo_lang_compiler::CairoLangSierraToCasmCompiler;
-use starknet_sierra_compile::config::SierraToCasmCompilationConfig;
 use starknet_sierra_compile::utils::into_contract_class_for_compilation;
 use starknet_sierra_compile::SierraToCasmCompiler;
 
+use crate::config::{GatewayCompilerConfig, PostCompilationConfig};
 use crate::errors::{GatewayError, GatewayResult};
 
 #[cfg(test)]
@@ -19,12 +19,18 @@ mod compilation_test;
 // TODO(Arni): Pass the compiler with dependancy injection.
 #[derive(Clone)]
 pub struct GatewayCompiler {
-    pub sierra_to_casm_compiler: Arc<dyn SierraToCasmCompiler>,
+    config: PostCompilationConfig,
+    sierra_to_casm_compiler: Arc<dyn SierraToCasmCompiler>,
 }
 
 impl GatewayCompiler {
-    pub fn new_cairo_lang_compiler(config: SierraToCasmCompilationConfig) -> Self {
-        Self { sierra_to_casm_compiler: Arc::new(CairoLangSierraToCasmCompiler { config }) }
+    pub fn new_cairo_lang_compiler(config: GatewayCompilerConfig) -> Self {
+        Self {
+            config: config.post_compilation_config,
+            sierra_to_casm_compiler: Arc::new(CairoLangSierraToCasmCompiler {
+                config: config.sierra_to_casm_compiler_config,
+            }),
+        }
     }
 
     /// Formats the contract class for compilation, compiles it, and returns the compiled contract
@@ -41,6 +47,7 @@ impl GatewayCompiler {
         let casm_contract_class = self.compile(cairo_lang_contract_class)?;
 
         validate_compiled_class_hash(&casm_contract_class, &tx.compiled_class_hash)?;
+        self.validate_casm_class_size(&casm_contract_class)?;
 
         Ok(ClassInfo::new(
             &ContractClass::V1(ContractClassV1::try_from(casm_contract_class)?),
@@ -55,6 +62,28 @@ impl GatewayCompiler {
     ) -> Result<CasmContractClass, GatewayError> {
         Ok(self.sierra_to_casm_compiler.compile(cairo_lang_contract_class)?)
     }
+
+    // TODO(Arni): consider validating the size of other members of the Casm class. Cosider removing
+    // the validation of the raw class size. The validation should be linked to the way the class is
+    // saved in Papyrus etc.
+    /// Validates that the Casm class is within size limit. Specifically, this function validates
+    /// the size of the serialized class.
+    fn validate_casm_class_size(
+        &self,
+        casm_contract_class: &CasmContractClass,
+    ) -> Result<(), GatewayError> {
+        let contract_class_object_size = serde_json::to_string(&casm_contract_class)
+            .expect("Unexpected error serializing Casm contract class.")
+            .len();
+        if contract_class_object_size > self.config.max_raw_casm_class_size {
+            return Err(GatewayError::CasmContractClassObjectSizeTooLarge {
+                contract_class_object_size,
+                max_contract_class_object_size: self.config.max_raw_casm_class_size,
+            });
+        }
+
+        Ok(())
+    }
 }
 
 /// Validates that the compiled class hash of the compiled contract class matches the supplied

crates/gateway/src/compilation_test.rs

@@ -15,11 +15,12 @@ use starknet_sierra_compile::config::SierraToCasmCompilationConfig;
 use starknet_sierra_compile::errors::CompilationUtilError;
 
 use crate::compilation::GatewayCompiler;
+use crate::config::{GatewayCompilerConfig, PostCompilationConfig};
 use crate::errors::GatewayError;
 
 #[fixture]
 fn gateway_compiler() -> GatewayCompiler {
-    GatewayCompiler::new_cairo_lang_compiler(SierraToCasmCompilationConfig::default())
+    GatewayCompiler::new_cairo_lang_compiler(GatewayCompilerConfig::default())
 }
 
 #[fixture]
@@ -52,10 +53,10 @@ fn test_compile_contract_class_compiled_class_hash_mismatch(
 // TODO(Arni): Redesign this test once the compiler is passed with dependancy injection.
 #[rstest]
 fn test_compile_contract_class_bytecode_size_validation(declare_tx_v3: RpcDeclareTransactionV3) {
-    let gateway_compiler =
-        GatewayCompiler::new_cairo_lang_compiler(SierraToCasmCompilationConfig {
-            max_bytecode_size: 1,
-        });
+    let gateway_compiler = GatewayCompiler::new_cairo_lang_compiler(GatewayCompilerConfig {
+        sierra_to_casm_compiler_config: SierraToCasmCompilationConfig { max_bytecode_size: 1 },
+        ..Default::default()
+    });
 
     let result = gateway_compiler.process_declare_tx(&RpcDeclareTransaction::V3(declare_tx_v3));
     assert_matches!(
@@ -67,6 +68,18 @@ fn test_compile_contract_class_bytecode_size_validation(declare_tx_v3: RpcDeclar
     )
 }
 
+// TODO(Arni): Redesign this test to use a mock compiler.
+#[rstest]
+fn test_compile_contract_class_raw_class_size_validation(declare_tx_v3: RpcDeclareTransactionV3) {
+    let gateway_compiler = GatewayCompiler::new_cairo_lang_compiler(GatewayCompilerConfig {
+        post_compilation_config: PostCompilationConfig { max_raw_casm_class_size: 1 },
+        ..Default::default()
+    });
+
+    let result = gateway_compiler.process_declare_tx(&RpcDeclareTransaction::V3(declare_tx_v3));
+    assert_matches!(result.unwrap_err(), GatewayError::CasmContractClassObjectSizeTooLarge { .. })
+}
+
 #[rstest]
 fn test_compile_contract_class_bad_sierra(
     gateway_compiler: GatewayCompiler,

crates/gateway/src/config.rs

@@ -6,6 +6,7 @@ use papyrus_config::dumping::{append_sub_config_name, ser_param, SerializeConfig
 use papyrus_config::{ParamPath, ParamPrivacyInput, SerializedParam};
 use serde::{Deserialize, Serialize};
 use starknet_api::core::Nonce;
+use starknet_sierra_compile::config::SierraToCasmCompilationConfig;
 use starknet_types_core::felt::Felt;
 use validator::Validate;
 
@@ -221,3 +222,47 @@ impl StatefulTransactionValidatorConfig {
         }
     }
 }
+
+#[derive(Clone, Copy, Debug, Default, Serialize, Deserialize, Validate, PartialEq)]
+pub struct GatewayCompilerConfig {
+    pub sierra_to_casm_compiler_config: SierraToCasmCompilationConfig,
+    pub post_compilation_config: PostCompilationConfig,
+}
+
+impl SerializeConfig for GatewayCompilerConfig {
+    fn dump(&self) -> BTreeMap<ParamPath, SerializedParam> {
+        vec![
+            append_sub_config_name(
+                self.sierra_to_casm_compiler_config.dump(),
+                "sierra_to_casm_compiler_config",
+            ),
+            append_sub_config_name(self.post_compilation_config.dump(), "post_compilation_config"),
+        ]
+        .into_iter()
+        .flatten()
+        .collect()
+    }
+}
+
+/// The configuration for the post compilation process in the gateway compiler.
+#[derive(Clone, Copy, Debug, Serialize, Deserialize, Validate, PartialEq)]
+pub struct PostCompilationConfig {
+    pub max_raw_casm_class_size: usize,
+}
+
+impl Default for PostCompilationConfig {
+    fn default() -> Self {
+        PostCompilationConfig { max_raw_casm_class_size: 4089446 }
+    }
+}
+
+impl SerializeConfig for PostCompilationConfig {
+    fn dump(&self) -> BTreeMap<ParamPath, SerializedParam> {
+        BTreeMap::from_iter([ser_param(
+            "max_raw_casm_class_size",
+            &self.max_raw_casm_class_size,
+            "Limitation of contract class object size.",
+            ParamPrivacyInput::Public,
+        )])
+    }
+}

crates/gateway/src/errors.rs

@@ -39,6 +39,14 @@ use crate::compiler_version::{VersionId, VersionIdError};
 /// Errors directed towards the end-user, as a result of gateway requests.
 #[derive(Debug, Error)]
 pub enum GatewayError {
+    #[error(
+        "Cannot declare Casm contract class with size of {contract_class_object_size}; max \
+         allowed size: {max_contract_class_object_size}."
+    )]
+    CasmContractClassObjectSizeTooLarge {
+        contract_class_object_size: usize,
+        max_contract_class_object_size: usize,
+    },
     #[error(transparent)]
     CompilationError(#[from] CompilationUtilError),
     #[error(

crates/gateway/src/gateway_test.rs

@@ -13,10 +13,13 @@ use starknet_api::rpc_transaction::RpcTransaction;
 use starknet_api::transaction::TransactionHash;
 use starknet_mempool_types::communication::MockMempoolClient;
 use starknet_mempool_types::mempool_types::{Account, AccountState, MempoolInput, ThinTransaction};
-use starknet_sierra_compile::config::SierraToCasmCompilationConfig;
 
 use crate::compilation::GatewayCompiler;
-use crate::config::{StatefulTransactionValidatorConfig, StatelessTransactionValidatorConfig};
+use crate::config::{
+    GatewayCompilerConfig,
+    StatefulTransactionValidatorConfig,
+    StatelessTransactionValidatorConfig,
+};
 use crate::gateway::{add_tx, AppState, SharedMempoolClient};
 use crate::state_reader_test_utils::{local_test_state_reader_factory, TestStateReaderFactory};
 use crate::stateful_transaction_validator::StatefulTransactionValidator;
@@ -34,9 +37,7 @@ pub fn app_state(
         stateful_tx_validator: Arc::new(StatefulTransactionValidator {
             config: StatefulTransactionValidatorConfig::create_for_testing(),
         }),
-        gateway_compiler: GatewayCompiler::new_cairo_lang_compiler(
-            SierraToCasmCompilationConfig::default(),
-        ),
+        gateway_compiler: GatewayCompiler::new_cairo_lang_compiler(GatewayCompilerConfig::default()),
         state_reader_factory: Arc::new(state_reader_factory),
         mempool_client,
     }

crates/gateway/src/stateful_transaction_validator_test.rs

@@ -19,11 +19,10 @@ use starknet_api::core::{ContractAddress, Nonce};
 use starknet_api::felt;
 use starknet_api::rpc_transaction::RpcTransaction;
 use starknet_api::transaction::TransactionHash;
-use starknet_sierra_compile::config::SierraToCasmCompilationConfig;
 use starknet_types_core::felt::Felt;
 
 use crate::compilation::GatewayCompiler;
-use crate::config::StatefulTransactionValidatorConfig;
+use crate::config::{GatewayCompilerConfig, StatefulTransactionValidatorConfig};
 use crate::errors::{StatefulTransactionValidatorError, StatefulTransactionValidatorResult};
 use crate::state_reader::{MockStateReaderFactory, StateReaderFactory};
 use crate::state_reader_test_utils::local_test_state_reader_factory;
@@ -84,7 +83,7 @@ fn test_stateful_tx_validator(
 ) {
     let optional_class_info = match &external_tx {
         RpcTransaction::Declare(declare_tx) => Some(
-            GatewayCompiler::new_cairo_lang_compiler(SierraToCasmCompilationConfig::default())
+            GatewayCompiler::new_cairo_lang_compiler(GatewayCompilerConfig::default())
                 .process_declare_tx(declare_tx)
                 .unwrap(),
         ),

crates/mempool_node/Cargo.toml

@@ -20,7 +20,6 @@ starknet_gateway.workspace = true
 starknet_mempool.workspace = true
 starknet_mempool_infra.workspace = true
 starknet_mempool_types.workspace = true
-starknet_sierra_compile.workspace = true
 tokio.workspace = true
 tracing.workspace = true
 validator.workspace = true

crates/mempool_node/src/config/mod.rs

@@ -15,12 +15,11 @@ use papyrus_config::dumping::{
 use papyrus_config::loading::load_and_process_config;
 use papyrus_config::{ConfigError, ParamPath, ParamPrivacyInput, SerializedParam};
 use serde::{Deserialize, Serialize};
-use starknet_gateway::config::{GatewayConfig, RpcStateReaderConfig};
+use starknet_gateway::config::{GatewayCompilerConfig, GatewayConfig, RpcStateReaderConfig};
 use starknet_mempool_infra::component_definitions::{
     LocalComponentCommunicationConfig,
     RemoteComponentCommunicationConfig,
 };
-use starknet_sierra_compile::config::SierraToCasmCompilationConfig;
 use validator::{Validate, ValidationError};
 
 use crate::version::VERSION_FULL;
@@ -202,7 +201,7 @@ pub struct MempoolNodeConfig {
     #[validate]
     pub rpc_state_reader_config: RpcStateReaderConfig,
     #[validate]
-    pub compiler_config: SierraToCasmCompilationConfig,
+    pub compiler_config: GatewayCompilerConfig,
 }
 
 impl SerializeConfig for MempoolNodeConfig {