feat(solis): update katana for solis

bin/solis/Cargo.toml

@@ -0,0 +1,43 @@
+[package]
+description = "A fast and lightweight local Starknet development sequencer."
+edition.workspace = true
+license-file.workspace = true
+name = "solis"
+repository.workspace = true
+version.workspace = true
+
+[dependencies]
+alloy-primitives.workspace = true
+anyhow.workspace = true
+cfg-if = "1.0.0"
+clap.workspace = true
+clap_complete.workspace = true
+common.workspace = true
+console.workspace = true
+dojo-metrics.workspace = true
+katana-core.workspace = true
+katana-executor.workspace = true
+katana-primitives.workspace = true
+katana-rpc-api.workspace = true
+katana-rpc.workspace = true
+serde_json.workspace = true
+shellexpand = "3.1.0"
+starknet_api.workspace = true
+tokio.workspace = true
+tracing-subscriber.workspace = true
+tracing.workspace = true
+url.workspace = true
+
+[dev-dependencies]
+assert_matches = "1.5.0"
+
+[features]
+default = [ "blockifier", "jemalloc", "messaging" ]
+
+blockifier = [ "katana-executor/blockifier" ]
+# Disable until SIR support Cairo 2.6.3
+#sir = [ "katana-executor/sir" ]
+
+jemalloc = [ "dojo-metrics/jemalloc" ]
+messaging = [ "katana-core/messaging" ]
+starknet-messaging = [ "katana-core/starknet-messaging", "messaging" ]

bin/solis/src/args.rs

@@ -0,0 +1,341 @@
+//! Katana binary executable.
+//!
+//! ## Feature Flags
+//!
+//! - `jemalloc`: Uses [jemallocator](https://github.com/tikv/jemallocator) as the global allocator.
+//!   This is **not recommended on Windows**. See [here](https://rust-lang.github.io/rfcs/1974-global-allocators.html#jemalloc)
+//!   for more info.
+//! - `jemalloc-prof`: Enables [jemallocator's](https://github.com/tikv/jemallocator) heap profiling
+//!   and leak detection functionality. See [jemalloc's opt.prof](https://jemalloc.net/jemalloc.3.html#opt.prof)
+//!   documentation for usage details. This is **not recommended on Windows**. See [here](https://rust-lang.github.io/rfcs/1974-global-allocators.html#jemalloc)
+//!   for more info.
+
+use std::net::SocketAddr;
+use std::path::PathBuf;
+
+use alloy_primitives::U256;
+use clap::{Args, Parser, Subcommand};
+use clap_complete::Shell;
+use common::parse::parse_socket_address;
+use katana_core::backend::config::{Environment, StarknetConfig};
+use katana_core::constants::{
+    DEFAULT_ETH_L1_GAS_PRICE, DEFAULT_INVOKE_MAX_STEPS, DEFAULT_SEQUENCER_ADDRESS,
+    DEFAULT_STRK_L1_GAS_PRICE, DEFAULT_VALIDATE_MAX_STEPS,
+};
+use katana_core::sequencer::SequencerConfig;
+use katana_primitives::block::GasPrices;
+use katana_primitives::chain::ChainId;
+use katana_primitives::genesis::allocation::DevAllocationsGenerator;
+use katana_primitives::genesis::constant::DEFAULT_PREFUNDED_ACCOUNT_BALANCE;
+use katana_primitives::genesis::Genesis;
+use katana_rpc::config::ServerConfig;
+use katana_rpc_api::ApiKind;
+use tracing::Subscriber;
+use tracing_subscriber::{fmt, EnvFilter};
+use url::Url;
+
+use crate::utils::{parse_genesis, parse_seed};
+
+#[derive(Parser, Debug)]
+#[command(author, version, about, long_about = None)]
+#[command(propagate_version = true)]
+pub struct KatanaArgs {
+    #[arg(long)]
+    #[arg(help = "Don't print anything on startup.")]
+    pub silent: bool,
+
+    #[arg(long)]
+    #[arg(conflicts_with = "block_time")]
+    #[arg(help = "Disable auto and interval mining, and mine on demand instead via an endpoint.")]
+    pub no_mining: bool,
+
+    #[arg(short, long)]
+    #[arg(value_name = "MILLISECONDS")]
+    #[arg(help = "Block time in milliseconds for interval mining.")]
+    pub block_time: Option<u64>,
+
+    #[arg(long)]
+    #[arg(value_name = "PATH")]
+    #[arg(help = "Directory path of the database to initialize from.")]
+    #[arg(long_help = "Directory path of the database to initialize from. The path must either \
+                       be an empty directory or a directory which already contains a previously \
+                       initialized Katana database.")]
+    pub db_dir: Option<PathBuf>,
+
+    #[arg(long)]
+    #[arg(value_name = "URL")]
+    #[arg(help = "The Starknet RPC provider to fork the network from.")]
+    pub rpc_url: Option<Url>,
+
+    #[arg(long)]
+    pub dev: bool,
+
+    #[arg(long)]
+    #[arg(help = "Output logs in JSON format.")]
+    pub json_log: bool,
+
+    /// Enable Prometheus metrics.
+    ///
+    /// The metrics will be served at the given interface and port.
+    #[arg(long, value_name = "SOCKET", value_parser = parse_socket_address, help_heading = "Metrics")]
+    pub metrics: Option<SocketAddr>,
+
+    #[arg(long)]
+    #[arg(requires = "rpc_url")]
+    #[arg(value_name = "BLOCK_NUMBER")]
+    #[arg(help = "Fork the network at a specific block.")]
+    pub fork_block_number: Option<u64>,
+
+    #[cfg(feature = "messaging")]
+    #[arg(long)]
+    #[arg(value_name = "PATH")]
+    #[arg(value_parser = katana_core::service::messaging::MessagingConfig::parse)]
+    #[arg(help = "Configure the messaging with an other chain.")]
+    #[arg(long_help = "Configure the messaging to allow Katana listening/sending messages on a \
+                       settlement chain that can be Ethereum or an other Starknet sequencer. \
+                       The configuration file details and examples can be found here: https://book.dojoengine.org/toolchain/katana/reference#messaging")]
+    pub messaging: Option<katana_core::service::messaging::MessagingConfig>,
+
+    #[command(flatten)]
+    #[command(next_help_heading = "Server options")]
+    pub server: ServerOptions,
+
+    #[command(flatten)]
+    #[command(next_help_heading = "Starknet options")]
+    pub starknet: StarknetOptions,
+
+    #[command(subcommand)]
+    pub command: Option<Commands>,
+}
+
+#[derive(Debug, Subcommand)]
+pub enum Commands {
+    #[command(about = "Generate shell completion file for specified shell")]
+    Completions { shell: Shell },
+}
+
+#[derive(Debug, Args, Clone)]
+pub struct ServerOptions {
+    #[arg(short, long)]
+    #[arg(default_value = "5050")]
+    #[arg(help = "Port number to listen on.")]
+    pub port: u16,
+
+    #[arg(long)]
+    #[arg(help = "The IP address the server will listen on.")]
+    pub host: Option<String>,
+
+    #[arg(long)]
+    #[arg(default_value = "100")]
+    #[arg(help = "Maximum number of concurrent connections allowed.")]
+    pub max_connections: u32,
+
+    #[arg(long)]
+    #[arg(value_delimiter = ',')]
+    #[arg(help = "Enables the CORS layer and sets the allowed origins, separated by commas.")]
+    pub allowed_origins: Option<Vec<String>>,
+}
+
+#[derive(Debug, Args, Clone)]
+pub struct StarknetOptions {
+    #[arg(long)]
+    #[arg(default_value = "0")]
+    #[arg(help = "Specify the seed for randomness of accounts to be predeployed.")]
+    pub seed: String,
+
+    #[arg(long = "accounts")]
+    #[arg(value_name = "NUM")]
+    #[arg(default_value = "10")]
+    #[arg(help = "Number of pre-funded accounts to generate.")]
+    pub total_accounts: u16,
+
+    #[arg(long)]
+    #[arg(help = "Disable charging fee when executing transactions.")]
+    pub disable_fee: bool,
+
+    #[arg(long)]
+    #[arg(help = "Disable validation when executing transactions.")]
+    pub disable_validate: bool,
+
+    #[command(flatten)]
+    #[command(next_help_heading = "Environment options")]
+    pub environment: EnvironmentOptions,
+
+    #[arg(long)]
+    #[arg(value_parser = parse_genesis)]
+    #[arg(conflicts_with_all(["rpc_url", "seed", "total_accounts"]))]
+    pub genesis: Option<Genesis>,
+}
+
+#[derive(Debug, Args, Clone)]
+pub struct EnvironmentOptions {
+    #[arg(long)]
+    #[arg(help = "The chain ID.")]
+    #[arg(long_help = "The chain ID. If a raw hex string (`0x` prefix) is provided, then it'd \
+                       used as the actual chain ID. Otherwise, it's represented as the raw \
+                       ASCII values. It must be a valid Cairo short string.")]
+    #[arg(default_value = "KATANA")]
+    #[arg(value_parser = ChainId::parse)]
+    pub chain_id: ChainId,
+
+    #[arg(long)]
+    #[arg(help = "The maximum number of steps available for the account validation logic.")]
+    #[arg(default_value_t = DEFAULT_VALIDATE_MAX_STEPS)]
+    pub validate_max_steps: u32,
+
+    #[arg(long)]
+    #[arg(help = "The maximum number of steps available for the account execution logic.")]
+    #[arg(default_value_t = DEFAULT_INVOKE_MAX_STEPS)]
+    pub invoke_max_steps: u32,
+
+    #[arg(long = "eth-gas-price")]
+    #[arg(conflicts_with = "genesis")]
+    #[arg(help = "The L1 ETH gas price. (denominated in wei)")]
+    #[arg(default_value_t = DEFAULT_ETH_L1_GAS_PRICE)]
+    pub l1_eth_gas_price: u128,
+
+    #[arg(long = "strk-gas-price")]
+    #[arg(conflicts_with = "genesis")]
+    #[arg(help = "The L1 STRK gas price. (denominated in fri)")]
+    #[arg(default_value_t = DEFAULT_STRK_L1_GAS_PRICE)]
+    pub l1_strk_gas_price: u128,
+}
+
+impl KatanaArgs {
+    pub fn init_logging(&self) -> Result<(), Box<dyn std::error::Error>> {
+        const DEFAULT_LOG_FILTER: &str = "info,executor=trace,forked_backend=trace,server=debug,\
+                                          katana_core=trace,blockifier=off,jsonrpsee_server=off,\
+                                          hyper=off,messaging=debug,node=error";
+
+        let builder = fmt::Subscriber::builder().with_env_filter(
+            EnvFilter::try_from_default_env().or(EnvFilter::try_new(DEFAULT_LOG_FILTER))?,
+        );
+
+        let subscriber: Box<dyn Subscriber + Send + Sync> = if self.json_log {
+            Box::new(builder.json().finish())
+        } else {
+            Box::new(builder.finish())
+        };
+
+        Ok(tracing::subscriber::set_global_default(subscriber)?)
+    }
+
+    pub fn sequencer_config(&self) -> SequencerConfig {
+        SequencerConfig {
+            block_time: self.block_time,
+            no_mining: self.no_mining,
+            #[cfg(feature = "messaging")]
+            messaging: self.messaging.clone(),
+        }
+    }
+
+    pub fn server_config(&self) -> ServerConfig {
+        let mut apis = vec![ApiKind::Starknet, ApiKind::Katana, ApiKind::Torii, ApiKind::Saya];
+        // only enable `katana` API in dev mode
+        if self.dev {
+            apis.push(ApiKind::Dev);
+        }
+
+        ServerConfig {
+            apis,
+            port: self.server.port,
+            host: self.server.host.clone().unwrap_or("0.0.0.0".into()),
+            max_connections: self.server.max_connections,
+            allowed_origins: self.server.allowed_origins.clone(),
+        }
+    }
+
+    pub fn starknet_config(&self) -> StarknetConfig {
+        let genesis = match self.starknet.genesis.clone() {
+            Some(genesis) => genesis,
+            None => {
+                let gas_prices = GasPrices {
+                    eth: self.starknet.environment.l1_eth_gas_price,
+                    strk: self.starknet.environment.l1_strk_gas_price,
+                };
+
+                let accounts = DevAllocationsGenerator::new(self.starknet.total_accounts)
+                    .with_seed(parse_seed(&self.starknet.seed))
+                    .with_balance(U256::from(DEFAULT_PREFUNDED_ACCOUNT_BALANCE))
+                    .generate();
+
+                let mut genesis = Genesis {
+                    gas_prices,
+                    sequencer_address: *DEFAULT_SEQUENCER_ADDRESS,
+                    ..Default::default()
+                };
+
+                genesis.extend_allocations(accounts.into_iter().map(|(k, v)| (k, v.into())));
+                genesis
+            }
+        };
+
+        StarknetConfig {
+            disable_fee: self.starknet.disable_fee,
+            disable_validate: self.starknet.disable_validate,
+            fork_rpc_url: self.rpc_url.clone(),
+            fork_block_number: self.fork_block_number,
+            env: Environment {
+                chain_id: self.starknet.environment.chain_id,
+                invoke_max_steps: self.starknet.environment.invoke_max_steps,
+                validate_max_steps: self.starknet.environment.validate_max_steps,
+            },
+            db_dir: self.db_dir.clone(),
+            genesis,
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_starknet_config_default() {
+        let args = KatanaArgs::parse_from(["katana"]);
+        let config = args.starknet_config();
+
+        assert!(!config.disable_fee);
+        assert!(!config.disable_validate);
+        assert_eq!(config.fork_rpc_url, None);
+        assert_eq!(config.fork_block_number, None);
+        assert_eq!(config.env.chain_id, ChainId::parse("KATANA").unwrap());
+        assert_eq!(config.env.invoke_max_steps, DEFAULT_INVOKE_MAX_STEPS);
+        assert_eq!(config.env.validate_max_steps, DEFAULT_VALIDATE_MAX_STEPS);
+        assert_eq!(config.db_dir, None);
+        assert_eq!(config.genesis.gas_prices.eth, DEFAULT_ETH_L1_GAS_PRICE);
+        assert_eq!(config.genesis.gas_prices.strk, DEFAULT_STRK_L1_GAS_PRICE);
+        assert_eq!(config.genesis.sequencer_address, *DEFAULT_SEQUENCER_ADDRESS);
+    }
+
+    #[test]
+    fn test_starknet_config_custom() {
+        let args = KatanaArgs::parse_from([
+            "katana",
+            "--disable-fee",
+            "--disable-validate",
+            "--chain-id",
+            "SN_GOERLI",
+            "--invoke-max-steps",
+            "200",
+            "--validate-max-steps",
+            "100",
+            "--db-dir",
+            "/path/to/db",
+            "--eth-gas-price",
+            "10",
+            "--strk-gas-price",
+            "20",
+        ]);
+        let config = args.starknet_config();
+
+        assert!(config.disable_fee);
+        assert!(config.disable_validate);
+        assert_eq!(config.env.chain_id, ChainId::GOERLI);
+        assert_eq!(config.env.invoke_max_steps, 200);
+        assert_eq!(config.env.validate_max_steps, 100);
+        assert_eq!(config.db_dir, Some(PathBuf::from("/path/to/db")));
+        assert_eq!(config.genesis.gas_prices.eth, 10);
+        assert_eq!(config.genesis.gas_prices.strk, 20);
+    }
+}