Breaking: Remove request body size limit; set class size declaration limits; reduce gas prices (#743)

* Reduce all gas prices from 1e11 to 1e9 FRI

Author: FabijanC

contracts/test_artifacts/cairo1/too_big/compilation_info.txt

@@ -0,0 +1,6 @@
+Compiled with:
+scarb 2.9.2 (5070ff374 2024-12-11)
+cairo: 2.9.2 (https://crates.io/crates/cairo-lang-compiler/2.9.2)
+sierra: 1.6.0
+
+Intercepted declaration, logged; this exceeds bytecode size, but not the serialized class size

contracts/test_artifacts/cairo1/too_big/generate_contract.sh

@@ -0,0 +1,39 @@
+#!/bin/bash
+
+set -euo pipefail
+
+if [ $# -ne 1 ]; then
+    echo >&2 "Error! Usage: $0 <N_PROPERTIES>"
+    exit 1
+fi
+
+N="$1"
+
+echo '#[starknet::contract]'
+echo 'pub mod Dummy {'
+echo '    use core::starknet::storage::{StoragePointerReadAccess, StoragePointerWriteAccess};'
+echo ''
+echo '    #[storage]'
+echo '    pub struct Storage {'
+
+for i in $(seq 1 $N); do
+    echo "        balance_$i: felt252,"
+done
+
+echo '    }'
+echo ''
+
+for i in $(seq 1 $N); do
+    echo '    #[external(v0)]'
+    echo "    pub fn increment_balance_$i(ref self: ContractState) {"
+    echo "        self.balance_$i.write(self.balance_$i.read() + 1)"
+    echo '    }'
+    echo ''
+    echo '    #[external(v0)]'
+    echo "    pub fn get_balance_$i(self: @ContractState) -> felt252 {"
+    echo "        self.balance_$i.read()"
+    echo '    }'
+    echo ''
+done
+
+echo '}'

contracts/test_artifacts/cairo1/too_big/too_big.sierra

@@ -90,15 +90,14 @@ pub const DEVNET_DEFAULT_SEED: u32 = 123;
 pub const DEVNET_DEFAULT_TEST_SEED: u32 = 123;
 pub const DEVNET_DEFAULT_TOTAL_ACCOUNTS: u8 = 10;
 pub const DEVNET_DEFAULT_INITIAL_BALANCE: u128 = 1_000_000_000_000_000_000_000;
-pub const DEVNET_DEFAULT_L1_GAS_PRICE: NonZeroU128 = nonzero!(100_000_000_000u128);
-pub const DEVNET_DEFAULT_L1_DATA_GAS_PRICE: NonZeroU128 = nonzero!(100_000_000_000u128);
-pub const DEVNET_DEFAULT_L2_GAS_PRICE: NonZeroU128 = nonzero!(100_000_000_000u128);
+pub const DEVNET_DEFAULT_L1_GAS_PRICE: NonZeroU128 = nonzero!(1_000_000_000u128);
+pub const DEVNET_DEFAULT_L1_DATA_GAS_PRICE: NonZeroU128 = nonzero!(1_000_000_000u128);
+pub const DEVNET_DEFAULT_L2_GAS_PRICE: NonZeroU128 = nonzero!(1_000_000_000u128);
 pub const DEVNET_DEFAULT_HOST: IpAddr = IpAddr::V4(Ipv4Addr::LOCALHOST);
 pub const DEVNET_DEFAULT_PORT: u16 = 5050;
 pub const DEVNET_DEFAULT_TIMEOUT: u16 = 120;
 pub const DEVNET_DEFAULT_CHAIN_ID: ChainId = ChainId::Testnet;
 pub const DEVNET_DEFAULT_STARTING_BLOCK_NUMBER: u64 = 0;
-pub const DEVNET_DEFAULT_REQUEST_BODY_SIZE_LIMIT: usize = 2_000_000;
 
 pub const USE_KZG_DA: bool = true;
 
@@ -111,3 +110,7 @@ pub const CHARGEABLE_ACCOUNT_ADDRESS: &str =
 
 pub const ENTRYPOINT_NOT_FOUND_ERROR_ENCODED: Felt =
     Felt::from_hex_unchecked("0x454e545259504f494e545f4e4f545f464f554e44");
+
+pub const MAXIMUM_CONTRACT_CLASS_SIZE: usize = 4_089_446;
+pub const MAXIMUM_CONTRACT_BYTECODE_SIZE: usize = 81_920;
+pub const MAXIMUM_SIERRA_LENGTH: usize = 81_920;

crates/starknet-devnet-core/src/constants.rs

@@ -78,6 +78,8 @@ pub enum Error {
     ClassAlreadyDeclared { msg: String },
     #[error("Requested entrypoint does not exist in the contract")]
     EntrypointNotFound,
+    #[error("Contract class size it too large")]
+    ContractClassSizeIsTooLarge,
 }
 
 impl From<starknet_types_core::felt::FromStrError> for Error {

crates/starknet-devnet-core/src/error.rs

@@ -9,10 +9,41 @@ use starknet_types::rpc::transactions::{
     BroadcastedDeclareTransaction, DeclareTransaction, Transaction, TransactionWithHash,
 };
 
+use crate::constants::{
+    MAXIMUM_CONTRACT_BYTECODE_SIZE, MAXIMUM_CONTRACT_CLASS_SIZE, MAXIMUM_SIERRA_LENGTH,
+};
 use crate::error::{DevnetResult, Error, TransactionValidationError};
 use crate::starknet::Starknet;
 use crate::state::CustomState;
 
+fn check_class_size(
+    executable_tx: &starknet_api::executable_transaction::DeclareTransaction,
+) -> DevnetResult<()> {
+    let serialized_class = serde_json::to_vec(&executable_tx.contract_class()).map_err(|e| {
+        Error::UnexpectedInternalError {
+            msg: format!("Could not determine class size via serialization: {e}"),
+        }
+    })?;
+
+    let sierra_length = executable_tx.class_info.sierra_program_length();
+    let casm_length = executable_tx.class_info.bytecode_length();
+    tracing::info!(
+        "Declaring class: serialized size: {} bytes, sierra: {} felts, casm: {} felts",
+        serialized_class.len(),
+        sierra_length,
+        casm_length,
+    );
+
+    if serialized_class.len() > MAXIMUM_CONTRACT_CLASS_SIZE
+        || sierra_length > MAXIMUM_SIERRA_LENGTH
+        || casm_length > MAXIMUM_CONTRACT_BYTECODE_SIZE
+    {
+        return Err(Error::ContractClassSizeIsTooLarge);
+    }
+
+    Ok(())
+}
+
 pub fn add_declare_transaction(
     starknet: &mut Starknet,
     broadcasted_declare_transaction: BroadcastedDeclareTransaction,
@@ -30,6 +61,8 @@ pub fn add_declare_transaction(
     let executable_tx =
         broadcasted_declare_transaction.create_sn_api_declare(&starknet.chain_id().to_felt())?;
 
+    check_class_size(&executable_tx)?;
+
     let transaction_hash = executable_tx.tx_hash.0;
     let class_hash = executable_tx.class_hash().0;
 

crates/starknet-devnet-core/src/starknet/add_declare_transaction.rs

@@ -71,6 +71,8 @@ pub enum ApiError {
     InvalidSubscriptionId,
     #[error("Devnet doesn't support storage proofs")] // slightly modified spec message
     StorageProofNotSupported,
+    #[error("Contract class size it too large")]
+    ContractClassSizeIsTooLarge,
 }
 
 impl ApiError {
@@ -236,6 +238,11 @@ impl ApiError {
                 message: error_message.into(),
                 data: None,
             },
+            ApiError::ContractClassSizeIsTooLarge => RpcError {
+                code: crate::rpc_core::error::ErrorCode::ServerError(57),
+                message: error_message.into(),
+                data: None,
+            },
         }
     }
 
@@ -271,6 +278,7 @@ impl ApiError {
             | Self::InvalidSubscriptionId
             | Self::InsufficientResourcesForValidate
             | Self::StorageProofNotSupported
+            | Self::ContractClassSizeIsTooLarge
             | Self::CompiledClassHashMismatch => false,
         }
     }

crates/starknet-devnet-server/src/api/json_rpc/error.rs

@@ -39,6 +39,9 @@ impl JsonRpcHandler {
                     starknet_core::error::Error::ClassAlreadyDeclared { .. } => {
                         ApiError::ClassAlreadyDeclared
                     }
+                    starknet_core::error::Error::ContractClassSizeIsTooLarge => {
+                        ApiError::ContractClassSizeIsTooLarge
+                    }
                     unknown_error => ApiError::StarknetDevnetError(unknown_error),
                 },
             )?;

crates/starknet-devnet-server/src/api/json_rpc/write_endpoints.rs

@@ -7,7 +7,6 @@ pub struct ServerConfig {
     pub host: IpAddr,
     pub port: u16,
     pub timeout: u16,
-    pub request_body_size_limit: usize,
     #[serde(skip)]
     pub log_request: bool,
     #[serde(skip)]

crates/starknet-devnet-server/src/config.rs

@@ -18,8 +18,6 @@ use tower_http::trace::TraceLayer;
 use crate::api::http::{HttpApiHandler, endpoints as http};
 use crate::api::json_rpc::JsonRpcHandler;
 use crate::restrictive_mode::is_uri_path_restricted;
-use crate::rpc_core::error::RpcError;
-use crate::rpc_core::response::ResponseResult;
 use crate::rpc_handler::RpcHandler;
 use crate::{ServerConfig, http_rpc_router, rpc_handler};
 pub type StarknetDevnetServer = axum::serve::Serve<IntoMakeService<Router>, Router>;
@@ -108,10 +106,6 @@ pub async fn serve_http_api_json_rpc(
     routes = routes
         .layer(TimeoutLayer::new(Duration::from_secs(server_config.timeout.into())))
         .layer(DefaultBodyLimit::disable())
-        .layer(axum::middleware::from_fn_with_state(
-            server_config.request_body_size_limit,
-            reject_too_big,
-        ))
         .layer(
             // More details: https://docs.rs/tower-http/latest/tower_http/cors/index.html
             CorsLayer::new()
@@ -172,40 +166,6 @@ async fn request_logging_middleware(
     Ok(next.run(Request::from_parts(parts, body)).await)
 }
 
-async fn reject_too_big(
-    State(payload_limit): State<usize>,
-    request: Request,
-    next: Next,
-) -> Result<impl IntoResponse, (StatusCode, String)> {
-    fn bad_request(e: impl std::fmt::Display) -> (StatusCode, String) {
-        (StatusCode::BAD_REQUEST, format!("Invalid Content-Length: {e}"))
-    }
-
-    if let Some(content_length) = request.headers().get(header::CONTENT_LENGTH) {
-        let content_length: usize =
-            content_length.to_str().map_err(bad_request)?.parse().map_err(bad_request)?;
-
-        if content_length > payload_limit {
-            return Err((
-                StatusCode::PAYLOAD_TOO_LARGE,
-                serde_json::to_string(&ResponseResult::Error(RpcError {
-                    code: crate::rpc_core::error::ErrorCode::InvalidRequest,
-                    message: format!(
-                        "Request too big! Server received: {content_length} bytes; maximum \
-                         (specifiable via --request-body-size-limit): {payload_limit} bytes"
-                    )
-                    .into(),
-                    data: None,
-                }))
-                .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?,
-            ));
-        }
-    }
-
-    let response = next.run(request).await;
-    Ok(response)
-}
-
 async fn response_logging_middleware(
     request: Request,
     next: Next,