wip

Author: kariy

.gitignore

@@ -40,3 +40,4 @@ crates/contracts/build/
 !crates/contracts/build/legacy/
 
 **/.claude/settings.local.json
+.cargo/config.toml

Cargo.lock

@@ -2,15 +2,15 @@ use std::sync::Arc;
 use std::time::Duration;
 
 use anyhow::{Context, Result};
-pub use clap::Parser;
+pub use clap::{Args, Parser};
 use katana_node::config::dev::DevConfig;
 use katana_node::config::execution::ExecutionConfig;
 use katana_node::config::metrics::MetricsConfig;
 use katana_node::config::rpc::RpcConfig;
 use katana_node::shard::config::{
     ShardNodeConfig, DEFAULT_BLOCK_POLL_INTERVAL, DEFAULT_TIME_QUANTUM,
 };
-use katana_node::shard::ShardNode;
+use katana_node::shard::Node;
 use serde::{Deserialize, Serialize};
 use tracing::info;
 use url::Url;
@@ -34,46 +34,24 @@ pub struct ShardNodeArgs {
     #[arg(long = "base-chain-url", value_name = "URL")]
     pub base_chain_url: Url,
 
-    /// Number of shard worker threads.
-    ///
-    /// Each worker runs on a dedicated OS thread and processes shards from the scheduler queue.
-    /// Defaults to the number of available CPU cores.
-    #[arg(long = "workers", value_name = "COUNT")]
-    pub workers: Option<usize>,
-
-    /// Time quantum in milliseconds for worker preemption.
-    ///
-    /// Controls how long a worker processes a single shard before yielding to allow other
-    /// shards to be serviced.
-    #[arg(long = "time-quantum", value_name = "MILLISECONDS")]
-    #[arg(default_value_t = DEFAULT_TIME_QUANTUM.as_millis() as u64)]
-    pub time_quantum_ms: u64,
-
     /// Base chain block poll interval in seconds.
     ///
     /// How frequently the shard node polls the base chain for new block context.
     #[arg(long = "block-poll-interval", value_name = "SECONDS")]
     #[arg(default_value_t = DEFAULT_BLOCK_POLL_INTERVAL.as_secs())]
     pub block_poll_interval_secs: u64,
 
-    /// Disable charging fee when executing transactions.
-    #[arg(long = "no-fee")]
-    pub no_fee: bool,
-
-    /// Disable account validation when executing transactions.
-    ///
-    /// Skipping the transaction sender's account validation function.
-    #[arg(long = "no-account-validation")]
-    pub no_account_validation: bool,
+    #[command(flatten)]
+    pub scheduler: SchedulerOptions,
 
     #[command(flatten)]
     pub logging: LoggingOptions,
 
     #[command(flatten)]
-    pub tracer: TracerOptions,
+    pub dev: DevOptions,
 
     #[command(flatten)]
-    pub starknet: EnvironmentOptions,
+    pub tracer: TracerOptions,
 
     #[cfg(feature = "server")]
     #[command(flatten)]
@@ -102,7 +80,7 @@ impl ShardNodeArgs {
 
     async fn start_node(&self) -> Result<()> {
         let config = self.config()?;
-        let node = ShardNode::build(config).context("failed to build shard node")?;
+        let node = Node::build(config).context("failed to build shard node")?;
 
         if !self.silent {
             info!(target: LOG_TARGET, "Starting shard node");
@@ -132,29 +110,23 @@ impl ShardNodeArgs {
         let metrics = self.metrics_config();
 
         let worker_count =
-            self.workers.unwrap_or_else(katana_node::shard::config::default_worker_count);
+            self.scheduler.workers.unwrap_or_else(katana_node::shard::config::default_worker_count);
 
         Ok(ShardNodeConfig {
             chain,
             rpc,
             execution,
             dev,
             worker_count,
-            time_quantum: Duration::from_millis(self.time_quantum_ms),
+            time_quantum: Duration::from_millis(self.scheduler.time_quantum_ms),
             base_chain_url: self.base_chain_url.clone(),
             block_poll_interval: Duration::from_secs(self.block_poll_interval_secs),
             metrics,
         })
     }
 
     fn chain_spec(&self) -> Arc<katana_chain_spec::ChainSpec> {
-        let mut chain_spec = katana_chain_spec::dev::DEV_UNALLOCATED.clone();
-
-        if let Some(id) = self.starknet.chain_id {
-            chain_spec.id = id;
-        }
-
-        Arc::new(katana_chain_spec::ChainSpec::Dev(chain_spec))
+        Arc::new(katana_chain_spec::ChainSpec::Dev(katana_chain_spec::dev::DEV_UNALLOCATED.clone()))
     }
 
     fn rpc_config(&self) -> Result<RpcConfig> {
@@ -187,19 +159,13 @@ impl ShardNodeArgs {
     }
 
     fn execution_config(&self) -> ExecutionConfig {
-        ExecutionConfig {
-            invocation_max_steps: self.starknet.invoke_max_steps,
-            validation_max_steps: self.starknet.validate_max_steps,
-            #[cfg(feature = "native")]
-            compile_native: self.starknet.compile_native,
-            ..Default::default()
-        }
+        ExecutionConfig::default()
     }
 
     fn dev_config(&self) -> DevConfig {
         DevConfig {
-            fee: !self.no_fee,
-            account_validation: !self.no_account_validation,
+            fee: !self.dev.no_fee,
+            account_validation: !self.dev.no_account_validation,
             fixed_gas_prices: None,
         }
     }
@@ -220,3 +186,22 @@ impl ShardNodeArgs {
         self.tracer.config()
     }
 }
+
+#[derive(Debug, Args, Clone, Serialize, Deserialize, PartialEq)]
+#[command(next_help_heading = "Scheduler options")]
+pub struct SchedulerOptions {
+    /// Number of shard worker threads.
+    ///
+    /// Each worker runs on a dedicated OS thread and processes shards from the scheduler queue.
+    /// Defaults to the number of available CPU cores.
+    #[arg(long = "scheduler.workers", value_name = "COUNT")]
+    pub workers: Option<usize>,
+
+    /// Time quantum in milliseconds for worker preemption.
+    ///
+    /// Controls how long a worker processes a single shard before yielding to allow other
+    /// shards to be serviced.
+    #[arg(long = "scheduler.time-quantum", value_name = "MILLISECONDS")]
+    #[arg(default_value_t = DEFAULT_TIME_QUANTUM.as_millis() as u64)]
+    pub time_quantum_ms: u64,
+}

crates/cli/src/shard.rs

@@ -1,4 +1,3 @@
-pub mod block_context;
 pub mod config;
 pub mod exit;
 
@@ -13,22 +12,20 @@ use katana_executor::blockifier::BlockifierFactory;
 use katana_executor::{ExecutionFlags, ExecutorFactory};
 use katana_gas_price_oracle::GasPriceOracle;
 use katana_pool::TxPool;
-use katana_primitives::env::{BlockEnv, VersionedConstantsOverrides};
+use katana_primitives::env::VersionedConstantsOverrides;
 use katana_primitives::{ContractAddress, Felt};
 use katana_provider::DbProviderFactory;
 use katana_rpc_api::shard::ShardApiServer;
-use katana_rpc_client::starknet::Client as StarknetClient;
 use katana_rpc_server::shard::{ShardProvider, ShardRpc};
 use katana_rpc_server::starknet::{StarknetApi, StarknetApiConfig};
 use katana_rpc_server::{RpcServer, RpcServerHandle};
 use katana_sharding::manager::{LazyShardManager, ShardManager};
 use katana_sharding::runtime::{RuntimeHandle, ShardRuntime};
 use katana_sharding::types::NoPendingBlockProvider;
 use katana_tasks::TaskManager;
-use parking_lot::{Mutex, RwLock};
+use parking_lot::Mutex;
 use tracing::info;
 
-use self::block_context::BlockContextListener;
 use self::config::ShardNodeConfig;
 use self::exit::ShardNodeStoppedFuture;
 
@@ -41,7 +38,6 @@ pub struct Node {
     pub handle: RuntimeHandle,
     pub task_manager: TaskManager,
     pub rpc_server: RpcServer,
-    pub block_context_listener: BlockContextListener,
     pub runtime: Mutex<Option<ShardRuntime>>,
 }
 
@@ -97,39 +93,18 @@ impl Node {
             paymaster: None,
         };
 
-        // --- Build initial BlockEnv from genesis
-        let genesis = config.chain.genesis();
-        let block_env = Arc::new(RwLock::new(BlockEnv {
-            number: genesis.number,
-            timestamp: genesis.timestamp,
-            sequencer_address: genesis.sequencer_address,
-            l1_gas_prices: genesis.gas_prices.clone(),
-            l2_gas_prices: genesis.gas_prices.clone(),
-            l1_data_gas_prices: genesis.gas_prices.clone(),
-            starknet_version: katana_primitives::version::CURRENT_STARKNET_VERSION,
-        }));
-
         // --- Build runtime (scheduler + workers)
-        let runtime =
-            ShardRuntime::new(config.worker_count, config.time_quantum, block_env.clone());
+        let runtime = ShardRuntime::new(config.worker_count, config.time_quantum);
         let handle = runtime.handle();
 
-        // --- Build base chain client and block context listener
-        let starknet_client = StarknetClient::new(config.base_chain_url.clone());
-        let block_context_listener = BlockContextListener::new(
-            starknet_client,
-            block_env,
-            config.chain.clone(),
-            config.block_poll_interval,
-        );
-
         // --- Build shard manager
         let manager: Arc<dyn ShardManager> = Arc::new(LazyShardManager::new(
             config.chain.clone(),
             executor_factory,
             gas_oracle,
             starknet_api_config,
             task_spawner.clone(),
+            config.base_chain_url.clone(),
         ));
 
         // --- Build RPC server with shard API
@@ -152,20 +127,11 @@ impl Node {
             handle,
             task_manager,
             rpc_server,
-            block_context_listener,
             runtime: Mutex::new(Some(runtime)),
         })
     }
 
     pub async fn launch(self) -> Result<LaunchedShardNode> {
-        let listener = self.block_context_listener.clone();
-        self.task_manager
-            .task_spawner()
-            .build_task()
-            .graceful_shutdown()
-            .name("Block context listener")
-            .spawn(listener.run());
-
         self.runtime.lock().as_mut().expect("runtime already taken").start();
 
         let rpc = self.rpc_server.start(self.config.rpc.socket_addr()).await?;

crates/node/src/shard/block_context.rs

@@ -14,11 +14,14 @@ katana-gas-price-oracle.workspace = true
 katana-pool.workspace = true
 katana-primitives.workspace = true
 katana-provider.workspace = true
+katana-rpc-client.workspace = true
 katana-rpc-server.workspace = true
 katana-rpc-types.workspace = true
 katana-rpc-api.workspace = true
 katana-tasks.workspace = true
 
 anyhow.workspace = true
 parking_lot.workspace = true
+tokio.workspace = true
 tracing.workspace = true
+url.workspace = true