feat(katana): added chunk size limit to events method

crates/dojo/test-utils/src/sequencer.rs

@@ -123,6 +123,7 @@ pub fn get_default_test_config(sequencing: SequencingConfig) -> Config {
         addr: DEFAULT_RPC_ADDR,
         max_connections: DEFAULT_RPC_MAX_CONNECTIONS,
         apis: HashSet::from([ApiKind::Starknet, ApiKind::Dev, ApiKind::Saya, ApiKind::Torii]),
+        max_event_page_size: Some(100),
     };
 
     Config { sequencing, rpc, dev, chain, ..Default::default() }

crates/katana/cli/src/args.rs

@@ -193,6 +193,7 @@ impl NodeArgs {
                 addr: self.server.http_addr,
                 max_connections: self.server.max_connections,
                 cors_origins: self.server.http_cors_origins.clone(),
+                max_event_page_size: Some(self.server.max_event_page_size),
             }
         }
 

crates/katana/cli/src/options.rs

@@ -13,7 +13,10 @@
 use katana_node::config::execution::{DEFAULT_INVOCATION_MAX_STEPS, DEFAULT_VALIDATION_MAX_STEPS};
 use katana_node::config::metrics::{DEFAULT_METRICS_ADDR, DEFAULT_METRICS_PORT};
 #[cfg(feature = "server")]
-use katana_node::config::rpc::{DEFAULT_RPC_ADDR, DEFAULT_RPC_MAX_CONNECTIONS, DEFAULT_RPC_PORT};
+use katana_node::config::rpc::{
+    DEFAULT_RPC_ADDR, DEFAULT_RPC_MAX_CONNECTIONS, DEFAULT_RPC_MAX_EVENT_PAGE_SIZE,
+    DEFAULT_RPC_PORT,
+};
 use katana_primitives::block::BlockHashOrNumber;
 use katana_primitives::chain::ChainId;
 use katana_primitives::genesis::Genesis;
@@ -89,6 +92,12 @@
     #[arg(default_value_t = DEFAULT_RPC_MAX_CONNECTIONS)]
     #[serde(default = "default_max_connections")]
     pub max_connections: u32,
+
+    /// Maximum page size for event queries.
+    #[arg(long = "rpc.max-event-page-size", value_name = "SIZE")]
+    #[arg(default_value_t = DEFAULT_RPC_MAX_EVENT_PAGE_SIZE)]
+    #[serde(default = "default_page_size")]
+    pub max_event_page_size: u64,
 }
 
 #[cfg(feature = "server")]
@@ -99,6 +108,7 @@
             http_port: DEFAULT_RPC_PORT,
             max_connections: DEFAULT_RPC_MAX_CONNECTIONS,
             http_cors_origins: None,
+            max_event_page_size: DEFAULT_RPC_MAX_EVENT_PAGE_SIZE,
         }
     }
 }
@@ -356,6 +366,10 @@
     DEFAULT_RPC_MAX_CONNECTIONS
 }
 
+fn default_page_size() -> u64 {
+    DEFAULT_RPC_MAX_EVENT_PAGE_SIZE
+}
+
 #[cfg(feature = "server")]
 fn default_metrics_addr() -> IpAddr {
     DEFAULT_METRICS_ADDR

crates/katana/node/src/config/rpc.rs

@@ -6,6 +6,9 @@ pub const DEFAULT_RPC_MAX_CONNECTIONS: u32 = 100;
 pub const DEFAULT_RPC_ADDR: IpAddr = IpAddr::V4(Ipv4Addr::LOCALHOST);
 pub const DEFAULT_RPC_PORT: u16 = 5050;
 
+/// Default maximmum page size for the `starknet_getEvents` RPC method.
+pub const DEFAULT_RPC_MAX_EVENT_PAGE_SIZE: u64 = 1024;
+
 /// List of APIs supported by Katana.
 #[derive(
     Debug, Copy, Clone, PartialEq, Eq, Hash, strum_macros::EnumString, strum_macros::Display,
@@ -24,6 +27,7 @@ pub struct RpcConfig {
     pub port: u16,
     pub max_connections: u32,
     pub apis: HashSet<ApiKind>,
+    pub max_event_page_size: Option<u64>,
     pub cors_origins: Option<Vec<String>>,
 }
 
@@ -42,6 +46,7 @@ impl Default for RpcConfig {
             port: DEFAULT_RPC_PORT,
             max_connections: DEFAULT_RPC_MAX_CONNECTIONS,
             apis: HashSet::from([ApiKind::Starknet]),
+            max_event_page_size: Some(DEFAULT_RPC_MAX_EVENT_PAGE_SIZE),
         }
     }
 }

crates/katana/node/src/lib.rs

@@ -42,7 +42,7 @@ use katana_rpc::dev::DevApi;
 use katana_rpc::metrics::RpcServerMetrics;
 use katana_rpc::saya::SayaApi;
 use katana_rpc::starknet::forking::ForkedClient;
-use katana_rpc::starknet::StarknetApi;
+use katana_rpc::starknet::{StarknetApi, StarknetApiConfig};
 use katana_rpc::torii::ToriiApi;
 use katana_rpc_api::dev::DevApiServer;
 use katana_rpc_api::saya::SayaApiServer;
@@ -277,16 +277,19 @@ pub async fn spawn<EF: ExecutorFactory>(
     methods.register_method("health", |_, _| Ok(serde_json::json!({ "health": true })))?;
 
     if config.apis.contains(&ApiKind::Starknet) {
+        let cfg = StarknetApiConfig { max_event_page_size: config.max_event_page_size };
+
         let server = if let Some(client) = forked_client {
             StarknetApi::new_forked(
                 backend.clone(),
                 pool.clone(),
                 block_producer.clone(),
                 validator,
                 client,
+                cfg,
             )
         } else {
-            StarknetApi::new(backend.clone(), pool.clone(), block_producer.clone(), validator)
+            StarknetApi::new(backend.clone(), pool.clone(), block_producer.clone(), validator, cfg)
         };
 
         methods.merge(StarknetApiServer::into_rpc(server.clone()))?;

crates/katana/rpc/rpc-types/src/error/starknet.rs

@@ -32,7 +32,7 @@
     #[error("Class hash not found")]
     ClassHashNotFound,
     #[error("Requested page size is too big")]
-    PageSizeTooBig,
+    PageSizeTooBig { requested: u64, max_allowed: u64 },
     #[error("There are no blocks")]
     NoBlocks,
     #[error("The supplied continuation token is invalid or unknown")]
@@ -96,7 +96,7 @@
             StarknetApiError::InvalidTxnIndex => 27,
             StarknetApiError::ClassHashNotFound => 28,
             StarknetApiError::TxnHashNotFound => 29,
-            StarknetApiError::PageSizeTooBig => 31,
+            StarknetApiError::PageSizeTooBig { .. } => 31,
             StarknetApiError::NoBlocks => 32,
             StarknetApiError::InvalidContinuationToken => 33,
             StarknetApiError::TooManyKeysInFilter => 34,
@@ -129,13 +129,13 @@
         match self {
             StarknetApiError::ContractError { .. }
             | StarknetApiError::UnexpectedError { .. }
+            | StarknetApiError::PageSizeTooBig { .. }
             | StarknetApiError::TransactionExecutionError { .. } => Some(serde_json::json!(self)),
 
             StarknetApiError::InvalidTransactionNonce { reason }
             | StarknetApiError::ValidationFailure { reason } => {
                 Some(Value::String(reason.to_string()))
             }
-
             _ => None,
         }
     }
@@ -206,7 +206,9 @@
             StarknetRsError::NoBlocks => Self::NoBlocks,
             StarknetRsError::NonAccount => Self::NonAccount,
             StarknetRsError::BlockNotFound => Self::BlockNotFound,
-            StarknetRsError::PageSizeTooBig => Self::PageSizeTooBig,
+            StarknetRsError::PageSizeTooBig => {
+                Self::PageSizeTooBig { requested: 0, max_allowed: 0 }
+            }
             StarknetRsError::DuplicateTx => Self::DuplicateTransaction,
             StarknetRsError::ContractNotFound => Self::ContractNotFound,
             StarknetRsError::CompilationFailed => Self::CompilationFailed,
@@ -278,7 +280,6 @@
     #[case(StarknetApiError::TxnHashNotFound, 29, "Transaction hash not found")]
     #[case(StarknetApiError::ClassAlreadyDeclared, 51, "Class already declared")]
     #[case(StarknetApiError::InvalidContractClass, 50, "Invalid contract class")]
-    #[case(StarknetApiError::PageSizeTooBig, 31, "Requested page size is too big")]
     #[case(StarknetApiError::FailedToReceiveTxn, 1, "Failed to write transaction")]
     #[case(StarknetApiError::InvalidMessageSelector, 21, "Invalid message selector")]
     #[case(StarknetApiError::NonAccount, 58, "Sender address in not an account contract")]
@@ -359,6 +360,18 @@
       	"Account validation failed",
        	Value::String("Invalid signature".to_string())
     )]
+    #[case(
+    	StarknetApiError::PageSizeTooBig {
+     		requested: 1000,
+       		max_allowed: 500
+     	},
+      	31,
+       	"Requested page size is too big",
+        json!({
+        	"requested": 1000,
+         	"max_allowed": 500
+        }),
+    )]
     fn test_starknet_api_error_to_error_conversion_data_some(
         #[case] starknet_error: StarknetApiError,
         #[case] expected_code: i32,

crates/katana/rpc/rpc/src/starknet/mod.rs

@@ -58,6 +58,11 @@
     inner: Arc<Inner<EF>>,
 }
 
+#[derive(Debug, Clone)]
+pub struct StarknetApiConfig {
+    pub max_event_page_size: Option<u64>,
+}
+
 impl<EF: ExecutorFactory> Clone for StarknetApi<EF> {
     fn clone(&self) -> Self {
         Self { inner: Arc::clone(&self.inner) }
@@ -71,6 +76,7 @@
     block_producer: BlockProducer<EF>,
     blocking_task_pool: BlockingTaskPool,
     forked_client: Option<ForkedClient>,
+    config: StarknetApiConfig,
 }
 
 impl<EF: ExecutorFactory> StarknetApi<EF> {
@@ -79,8 +85,9 @@
         pool: TxPool,
         block_producer: BlockProducer<EF>,
         validator: TxValidator,
+        config: StarknetApiConfig,
     ) -> Self {
-        Self::new_inner(backend, pool, block_producer, validator, None)
+        Self::new_inner(backend, pool, block_producer, validator, None, config)
     }
 
     pub fn new_forked(
@@ -89,8 +96,9 @@
         block_producer: BlockProducer<EF>,
         validator: TxValidator,
         forked_client: ForkedClient,
+        config: StarknetApiConfig,
     ) -> Self {
-        Self::new_inner(backend, pool, block_producer, validator, Some(forked_client))
+        Self::new_inner(backend, pool, block_producer, validator, Some(forked_client), config)
     }
 
     fn new_inner(
@@ -99,11 +107,19 @@
         block_producer: BlockProducer<EF>,
         validator: TxValidator,
         forked_client: Option<ForkedClient>,
+        config: StarknetApiConfig,
     ) -> Self {
         let blocking_task_pool =
             BlockingTaskPool::new().expect("failed to create blocking task pool");
-        let inner =
-            Inner { pool, backend, block_producer, blocking_task_pool, validator, forked_client };
+        let inner = Inner {
+            pool,
+            backend,
+            block_producer,
+            blocking_task_pool,
+            validator,
+            forked_client,
+            config,
+        };
         Self { inner: Arc::new(inner) }
     }
 
@@ -816,6 +832,15 @@
         let EventFilterWithPage { event_filter, result_page_request } = filter;
         let ResultPageRequest { continuation_token, chunk_size } = result_page_request;
 
+        if let Some(max_size) = self.inner.config.max_event_page_size {
+            if chunk_size > max_size {
+                return Err(StarknetApiError::PageSizeTooBig {
+                    requested: chunk_size,
+                    max_allowed: max_size,
+                });
+            }
+        }
+
         self.on_io_blocking_task(move |this| {
             let from = match event_filter.from_block {
                 Some(id) => id,