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

@@ -24,6 +24,7 @@ use crate::utils::{parse_block_hash_or_number, parse_genesis, LogFormat};
 
 const DEFAULT_DEV_SEED: &str = "0";
 const DEFAULT_DEV_ACCOUNTS: u16 = 10;
+const DEFAULT_RPC_PAGE_SIZE: u64 = 100;
 
 #[cfg(feature = "server")]
 #[derive(Debug, Args, Clone, Serialize, Deserialize, PartialEq)]
@@ -89,6 +90,12 @@ pub struct ServerOptions {
     #[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_PAGE_SIZE)]
+    #[serde(default = "default_page_size")]
+    pub max_event_page_size: u64,
 }
 
 #[cfg(feature = "server")]
@@ -99,6 +106,7 @@ impl Default for ServerOptions {
             http_port: DEFAULT_RPC_PORT,
             max_connections: DEFAULT_RPC_MAX_CONNECTIONS,
             http_cors_origins: None,
+            max_event_page_size: DEFAULT_RPC_PAGE_SIZE,
         }
     }
 }
@@ -356,6 +364,10 @@ fn default_max_connections() -> u32 {
     DEFAULT_RPC_MAX_CONNECTIONS
 }
 
+fn default_page_size() -> u64 {
+    DEFAULT_RPC_PAGE_SIZE
+}
+
 #[cfg(feature = "server")]
 fn default_metrics_addr() -> IpAddr {
     DEFAULT_METRICS_ADDR

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

@@ -5,7 +5,7 @@ use std::net::{IpAddr, Ipv4Addr, SocketAddr};
 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;
-
+pub const DEFAULT_RPC_PAGE_SIZE: u64 = 100;
 /// List of APIs supported by Katana.
 #[derive(
     Debug, Copy, Clone, PartialEq, Eq, Hash, strum_macros::EnumString, strum_macros::Display,
@@ -24,6 +24,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 +43,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_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,25 @@ pub async fn spawn<EF: ExecutorFactory>(
     methods.register_method("health", |_, _| Ok(serde_json::json!({ "health": true })))?;
 
     if config.apis.contains(&ApiKind::Starknet) {
+        let starknet_api_config =
+            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,
+                starknet_api_config,
             )
         } else {
-            StarknetApi::new(backend.clone(), pool.clone(), block_producer.clone(), validator)
+            StarknetApi::new(
+                backend.clone(),
+                pool.clone(),
+                block_producer.clone(),
+                validator,
+                starknet_api_config,
+            )
         };
 
         methods.merge(StarknetApiServer::into_rpc(server.clone()))?;

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

@@ -32,7 +32,7 @@ pub enum StarknetApiError {
     #[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 @@ impl StarknetApiError {
             StarknetApiError::InvalidTxnIndex => 27,
             StarknetApiError::ClassHashNotFound => 28,
             StarknetApiError::TxnHashNotFound => 29,
-            StarknetApiError::PageSizeTooBig => 31,
+            StarknetApiError::PageSizeTooBig { .. } => 31,
             StarknetApiError::NoBlocks => 32,
             StarknetApiError::InvalidContinuationToken => 33,
             StarknetApiError::TooManyKeysInFilter => 34,
@@ -136,6 +136,9 @@ impl StarknetApiError {
                 Some(Value::String(reason.to_string()))
             }
 
+            StarknetApiError::PageSizeTooBig { requested: _, max_allowed: _ } => {
+                Some(serde_json::json!(self))
+            }
             _ => None,
         }
     }
@@ -206,7 +209,9 @@ impl From<StarknetRsError> for StarknetApiError {
             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 +283,7 @@ mod tests {
     #[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::PageSizeTooBig{requested: 1000, max_allowed: 500}, 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")]

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

@@ -58,6 +58,11 @@ pub struct StarknetApi<EF: ExecutorFactory> {
     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 @@ struct Inner<EF: ExecutorFactory> {
     block_producer: BlockProducer<EF>,
     blocking_task_pool: BlockingTaskPool,
     forked_client: Option<ForkedClient>,
+    config: StarknetApiConfig,
 }
 
 impl<EF: ExecutorFactory> StarknetApi<EF> {
@@ -79,8 +85,9 @@ impl<EF: ExecutorFactory> StarknetApi<EF> {
         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 @@ impl<EF: ExecutorFactory> StarknetApi<EF> {
         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 @@ impl<EF: ExecutorFactory> StarknetApi<EF> {
         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 @@ impl<EF: ExecutorFactory> StarknetApi<EF> {
         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,