diff --git a/yarn.lock b/yarn.lock
index 3c764c7c7b7f..531f49abc000 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -9816,7 +9816,7 @@ string-length@^4.0.1:
     char-regex "^1.0.2"
     strip-ansi "^6.0.0"
 
-"string-width-cjs@npm:string-width@^4.2.0":
+"string-width-cjs@npm:string-width@^4.2.0", string-width@^4.0.0, string-width@^4.1.0, string-width@^4.2.0, string-width@^4.2.2, string-width@^4.2.3:
   version "4.2.3"
   resolved "https://registry.yarnpkg.com/string-width/-/string-width-4.2.3.tgz#269c7117d27b05ad2e536830a8ec895ef9c6d010"
   integrity sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==
@@ -9833,15 +9833,6 @@ string-width@^2.1.0, string-width@^2.1.1:
     is-fullwidth-code-point "^2.0.0"
     strip-ansi "^4.0.0"
 
-string-width@^4.0.0, string-width@^4.1.0, string-width@^4.2.0, string-width@^4.2.2, string-width@^4.2.3:
-  version "4.2.3"
-  resolved "https://registry.yarnpkg.com/string-width/-/string-width-4.2.3.tgz#269c7117d27b05ad2e536830a8ec895ef9c6d010"
-  integrity sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==
-  dependencies:
-    emoji-regex "^8.0.0"
-    is-fullwidth-code-point "^3.0.0"
-    strip-ansi "^6.0.1"
-
 string-width@^5.0.1, string-width@^5.1.2:
   version "5.1.2"
   resolved "https://registry.yarnpkg.com/string-width/-/string-width-5.1.2.tgz#14f8daec6d81e7221d2a357e668cab73bdbca794"
@@ -9908,7 +9899,7 @@ string_decoder@~1.1.1:
   dependencies:
     safe-buffer "~5.1.0"
 
-"strip-ansi-cjs@npm:strip-ansi@^6.0.1":
+"strip-ansi-cjs@npm:strip-ansi@^6.0.1", strip-ansi@^6.0.0, strip-ansi@^6.0.1:
   version "6.0.1"
   resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-6.0.1.tgz#9e26c63d30f53443e9489495b2105d37b67a85d9"
   integrity sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==
@@ -9929,13 +9920,6 @@ strip-ansi@^5.1.0:
   dependencies:
     ansi-regex "^4.1.0"
 
-strip-ansi@^6.0.0, strip-ansi@^6.0.1:
-  version "6.0.1"
-  resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-6.0.1.tgz#9e26c63d30f53443e9489495b2105d37b67a85d9"
-  integrity sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==
-  dependencies:
-    ansi-regex "^5.0.1"
-
 strip-ansi@^7.0.1:
   version "7.1.0"
   resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-7.1.0.tgz#d5b6568ca689d8561370b0707685d22434faff45"
@@ -10781,16 +10765,7 @@ workerpool@6.2.1:
   resolved "https://registry.yarnpkg.com/workerpool/-/workerpool-6.2.1.tgz#46fc150c17d826b86a008e5a4508656777e9c343"
   integrity sha512-ILEIE97kDZvF9Wb9f6h5aXK4swSlKGUcOEGiIYb2OOu/IrDU9iwj0fD//SsA6E5ibwJxpEvhullJY4Sl4GcpAw==
 
-"wrap-ansi-cjs@npm:wrap-ansi@^7.0.0":
-  version "7.0.0"
-  resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-7.0.0.tgz#67e145cff510a6a6984bdf1152911d69d2eb9e43"
-  integrity sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==
-  dependencies:
-    ansi-styles "^4.0.0"
-    string-width "^4.1.0"
-    strip-ansi "^6.0.0"
-
-wrap-ansi@^7.0.0:
+"wrap-ansi-cjs@npm:wrap-ansi@^7.0.0", wrap-ansi@^7.0.0:
   version "7.0.0"
   resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-7.0.0.tgz#67e145cff510a6a6984bdf1152911d69d2eb9e43"
   integrity sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==
diff --git a/zk_toolbox/crates/zk_inception/src/commands/chain/accept_chain_ownership.rs b/zk_toolbox/crates/zk_inception/src/commands/chain/accept_chain_ownership.rs
new file mode 100644
index 000000000000..37d69fcf5bcc
--- /dev/null
+++ b/zk_toolbox/crates/zk_inception/src/commands/chain/accept_chain_ownership.rs
@@ -0,0 +1,42 @@
+use anyhow::Context;
+use common::{forge::ForgeScriptArgs, logger, spinner::Spinner};
+use config::EcosystemConfig;
+use xshell::Shell;
+
+use crate::{
+    accept_ownership::accept_admin,
+    messages::{
+        MSG_ACCEPTING_ADMIN_SPINNER, MSG_CHAIN_NOT_INITIALIZED, MSG_CHAIN_OWNERSHIP_TRANSFERRED,
+        MSG_L1_SECRETS_MUST_BE_PRESENTED,
+    },
+};
+
+pub async fn run(args: ForgeScriptArgs, shell: &Shell) -> anyhow::Result<()> {
+    let ecosystem_config = EcosystemConfig::from_file(shell)?;
+    let chain_config = ecosystem_config
+        .load_current_chain()
+        .context(MSG_CHAIN_NOT_INITIALIZED)?;
+    let contracts = chain_config.get_contracts_config()?;
+    let secrets = chain_config.get_secrets_config()?;
+    let l1_rpc_url = secrets
+        .l1
+        .context(MSG_L1_SECRETS_MUST_BE_PRESENTED)?
+        .l1_rpc_url
+        .expose_str()
+        .to_string();
+
+    let spinner = Spinner::new(MSG_ACCEPTING_ADMIN_SPINNER);
+    accept_admin(
+        shell,
+        &ecosystem_config,
+        contracts.l1.chain_admin_addr,
+        chain_config.get_wallets_config()?.governor_private_key(),
+        contracts.l1.diamond_proxy_addr,
+        &args,
+        l1_rpc_url.clone(),
+    )
+    .await?;
+    spinner.finish();
+    logger::success(MSG_CHAIN_OWNERSHIP_TRANSFERRED);
+    Ok(())
+}
diff --git a/zk_toolbox/crates/zk_inception/src/commands/chain/args/create.rs b/zk_toolbox/crates/zk_inception/src/commands/chain/args/create.rs
index 3ea15d10f8be..5fc46c1b227a 100644
--- a/zk_toolbox/crates/zk_inception/src/commands/chain/args/create.rs
+++ b/zk_toolbox/crates/zk_inception/src/commands/chain/args/create.rs
@@ -127,7 +127,7 @@ impl ChainCreateArgs {
                 .ask()
             });
 
-        let wallet_path: Option<PathBuf> = if self.wallet_creation == Some(WalletCreation::InFile) {
+        let wallet_path: Option<PathBuf> = if wallet_creation == WalletCreation::InFile {
             Some(self.wallet_path.unwrap_or_else(|| {
                 Prompt::new(MSG_WALLET_PATH_PROMPT)
                     .validate_with(|val: &String| {
diff --git a/zk_toolbox/crates/zk_inception/src/commands/chain/args/genesis.rs b/zk_toolbox/crates/zk_inception/src/commands/chain/args/genesis.rs
index 483b78e9b267..21796b3179de 100644
--- a/zk_toolbox/crates/zk_inception/src/commands/chain/args/genesis.rs
+++ b/zk_toolbox/crates/zk_inception/src/commands/chain/args/genesis.rs
@@ -1,3 +1,4 @@
+use anyhow::Context;
 use clap::Parser;
 use common::{db::DatabaseConfig, Prompt};
 use config::ChainConfig;
@@ -77,6 +78,46 @@ impl GenesisArgs {
             }
         }
     }
+
+    pub fn fill_values_with_secrets(
+        mut self,
+        chain_config: &ChainConfig,
+    ) -> anyhow::Result<GenesisArgsFinal> {
+        let secrets = chain_config.get_secrets_config()?;
+        let database = secrets
+            .database
+            .context("Database secrets must be present")?;
+
+        let (server_db_url, server_db_name) = if let Some(db_full_url) = database.server_url {
+            let db_config = DatabaseConfig::from_url(db_full_url.expose_url())
+                .context("Invalid server database URL")?;
+            (Some(db_config.url), Some(db_config.name))
+        } else {
+            (None, None)
+        };
+
+        let (prover_db_url, prover_db_name) = if let Some(db_full_url) = database.prover_url {
+            let db_config = DatabaseConfig::from_url(db_full_url.expose_url())
+                .context("Invalid prover database URL")?;
+            (Some(db_config.url), Some(db_config.name))
+        } else {
+            (None, None)
+        };
+
+        self.server_db_url = self.server_db_url.or(server_db_url);
+        self.server_db_name = self.server_db_name.or(server_db_name);
+        self.prover_db_url = self.prover_db_url.or(prover_db_url);
+        self.prover_db_name = self.prover_db_name.or(prover_db_name);
+
+        Ok(self.fill_values_with_prompt(chain_config))
+    }
+
+    pub fn reset_db_names(&mut self) {
+        self.prover_db_name = None;
+        self.prover_db_url = None;
+        self.server_db_name = None;
+        self.server_db_url = None;
+    }
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
diff --git a/zk_toolbox/crates/zk_inception/src/commands/chain/args/init/configs.rs b/zk_toolbox/crates/zk_inception/src/commands/chain/args/init/configs.rs
new file mode 100644
index 000000000000..b4a49f29d219
--- /dev/null
+++ b/zk_toolbox/crates/zk_inception/src/commands/chain/args/init/configs.rs
@@ -0,0 +1,70 @@
+use clap::Parser;
+use common::Prompt;
+use config::ChainConfig;
+use serde::{Deserialize, Serialize};
+use types::L1Network;
+use url::Url;
+
+use crate::{
+    commands::chain::args::{
+        genesis::{GenesisArgs, GenesisArgsFinal},
+        init::InitArgsFinal,
+    },
+    defaults::LOCAL_RPC_URL,
+    messages::{
+        MSG_GENESIS_ARGS_HELP, MSG_L1_RPC_URL_HELP, MSG_L1_RPC_URL_INVALID_ERR,
+        MSG_L1_RPC_URL_PROMPT, MSG_NO_PORT_REALLOCATION_HELP
+    },
+};
+
+#[derive(Debug, Clone, Serialize, Deserialize, Parser)]
+pub struct InitConfigsArgs {
+    #[clap(flatten, next_help_heading = MSG_GENESIS_ARGS_HELP)]
+    #[serde(flatten)]
+    pub genesis_args: GenesisArgs,
+    #[clap(long, help = MSG_L1_RPC_URL_HELP)]
+    pub l1_rpc_url: Option<String>,
+    #[clap(long, help = MSG_NO_PORT_REALLOCATION_HELP, default_value = "false", default_missing_value = "true", num_args = 0..=1)]
+    pub no_port_reallocation: bool,
+}
+
+#[derive(Debug, Serialize, Deserialize, Clone)]
+pub struct InitConfigsArgsFinal {
+    pub genesis_args: GenesisArgsFinal,
+    pub l1_rpc_url: String,
+    pub no_port_reallocation: bool,
+}
+
+impl InitConfigsArgs {
+    pub fn fill_values_with_prompt(self, config: &ChainConfig) -> InitConfigsArgsFinal {
+        let l1_rpc_url = self.l1_rpc_url.unwrap_or_else(|| {
+            let mut prompt = Prompt::new(MSG_L1_RPC_URL_PROMPT);
+            if config.l1_network == L1Network::Localhost {
+                prompt = prompt.default(LOCAL_RPC_URL);
+            }
+            prompt
+                .validate_with(|val: &String| -> Result<(), String> {
+                    Url::parse(val)
+                        .map(|_| ())
+                        .map_err(|_| MSG_L1_RPC_URL_INVALID_ERR.to_string())
+                })
+                .ask()
+        });
+
+        InitConfigsArgsFinal {
+            genesis_args: self.genesis_args.fill_values_with_prompt(config),
+            l1_rpc_url,
+            no_port_reallocation: self.no_port_reallocation,
+        }
+    }
+}
+
+impl InitConfigsArgsFinal {
+    pub fn from_chain_init_args(init_args: &InitArgsFinal) -> InitConfigsArgsFinal {
+        InitConfigsArgsFinal {
+            genesis_args: init_args.genesis_args.clone(),
+            l1_rpc_url: init_args.l1_rpc_url.clone(),
+            no_port_reallocation: init_args.no_port_reallocation,
+        }
+    }
+}
diff --git a/zk_toolbox/crates/zk_inception/src/commands/chain/args/init.rs b/zk_toolbox/crates/zk_inception/src/commands/chain/args/init/mod.rs
similarity index 96%
rename from zk_toolbox/crates/zk_inception/src/commands/chain/args/init.rs
rename to zk_toolbox/crates/zk_inception/src/commands/chain/args/init/mod.rs
index 24a0539f27d1..be4d28202b80 100644
--- a/zk_toolbox/crates/zk_inception/src/commands/chain/args/init.rs
+++ b/zk_toolbox/crates/zk_inception/src/commands/chain/args/init/mod.rs
@@ -5,9 +5,8 @@ use serde::{Deserialize, Serialize};
 use types::L1Network;
 use url::Url;
 
-use super::genesis::GenesisArgsFinal;
 use crate::{
-    commands::chain::args::genesis::GenesisArgs,
+    commands::chain::args::genesis::{GenesisArgs, GenesisArgsFinal},
     defaults::LOCAL_RPC_URL,
     messages::{
         MSG_DEPLOY_PAYMASTER_PROMPT, MSG_GENESIS_ARGS_HELP, MSG_L1_RPC_URL_HELP,
@@ -15,6 +14,8 @@ use crate::{
     },
 };
 
+pub mod configs;
+
 #[derive(Debug, Clone, Serialize, Deserialize, Parser)]
 pub struct InitArgs {
     /// All ethereum environment related arguments
diff --git a/zk_toolbox/crates/zk_inception/src/commands/chain/build_transactions.rs b/zk_toolbox/crates/zk_inception/src/commands/chain/build_transactions.rs
index 98b2e226cc13..5f1be15231bf 100644
--- a/zk_toolbox/crates/zk_inception/src/commands/chain/build_transactions.rs
+++ b/zk_toolbox/crates/zk_inception/src/commands/chain/build_transactions.rs
@@ -6,9 +6,10 @@ use config::{
 use ethers::utils::hex::ToHex;
 use xshell::Shell;
 
-use super::common::register_chain;
 use crate::{
-    commands::chain::args::build_transactions::BuildTransactionsArgs,
+    commands::chain::{
+        args::build_transactions::BuildTransactionsArgs, register_chain::register_chain,
+    },
     messages::{
         MSG_BUILDING_CHAIN_REGISTRATION_TXNS_SPINNER, MSG_CHAIN_NOT_FOUND_ERR,
         MSG_CHAIN_TRANSACTIONS_BUILT, MSG_CHAIN_TXN_MISSING_CONTRACT_CONFIG,
diff --git a/zk_toolbox/crates/zk_inception/src/commands/chain/common.rs b/zk_toolbox/crates/zk_inception/src/commands/chain/common.rs
index 0aabc16154ee..e0aa0b4e0470 100644
--- a/zk_toolbox/crates/zk_inception/src/commands/chain/common.rs
+++ b/zk_toolbox/crates/zk_inception/src/commands/chain/common.rs
@@ -1,66 +1,12 @@
-use common::{
-    forge::{Forge, ForgeScriptArgs},
-    spinner::Spinner,
-};
-use config::{
-    forge_interface::{
-        register_chain::{input::RegisterChainL1Config, output::RegisterChainOutput},
-        script_params::REGISTER_CHAIN_SCRIPT_PARAMS,
-    },
-    traits::{ReadConfig, SaveConfig},
-    ChainConfig, ContractsConfig, EcosystemConfig,
-};
+use common::spinner::Spinner;
+use config::{ChainConfig, EcosystemConfig};
 use types::{BaseToken, L1Network, WalletCreation};
-use xshell::Shell;
 
 use crate::{
     consts::AMOUNT_FOR_DISTRIBUTION_TO_WALLETS,
     messages::{MSG_DISTRIBUTING_ETH_SPINNER, MSG_MINT_BASE_TOKEN_SPINNER},
-    utils::forge::{check_the_balance, fill_forge_private_key},
 };
 
-#[allow(clippy::too_many_arguments)]
-pub async fn register_chain(
-    shell: &Shell,
-    forge_args: ForgeScriptArgs,
-    config: &EcosystemConfig,
-    chain_config: &ChainConfig,
-    contracts: &mut ContractsConfig,
-    l1_rpc_url: String,
-    sender: Option<String>,
-    broadcast: bool,
-) -> anyhow::Result<()> {
-    let deploy_config_path = REGISTER_CHAIN_SCRIPT_PARAMS.input(&config.link_to_code);
-
-    let deploy_config = RegisterChainL1Config::new(chain_config, contracts)?;
-    deploy_config.save(shell, deploy_config_path)?;
-
-    let mut forge = Forge::new(&config.path_to_foundry())
-        .script(&REGISTER_CHAIN_SCRIPT_PARAMS.script(), forge_args.clone())
-        .with_ffi()
-        .with_rpc_url(l1_rpc_url);
-
-    if broadcast {
-        forge = forge.with_broadcast();
-    }
-
-    if let Some(address) = sender {
-        forge = forge.with_sender(address);
-    } else {
-        forge = fill_forge_private_key(forge, config.get_wallets()?.governor_private_key())?;
-        check_the_balance(&forge).await?;
-    }
-
-    forge.run(shell)?;
-
-    let register_chain_output = RegisterChainOutput::read(
-        shell,
-        REGISTER_CHAIN_SCRIPT_PARAMS.output(&chain_config.link_to_code),
-    )?;
-    contracts.set_chain_contracts(&register_chain_output);
-    Ok(())
-}
-
 // Distribute eth to the chain wallets for localhost environment
 pub async fn distribute_eth(
     ecosystem_config: &EcosystemConfig,
diff --git a/zk_toolbox/crates/zk_inception/src/commands/chain/genesis.rs b/zk_toolbox/crates/zk_inception/src/commands/chain/genesis/database.rs
similarity index 63%
rename from zk_toolbox/crates/zk_inception/src/commands/chain/genesis.rs
rename to zk_toolbox/crates/zk_inception/src/commands/chain/genesis/database.rs
index c72183e98b77..bb78979ec38e 100644
--- a/zk_toolbox/crates/zk_inception/src/commands/chain/genesis.rs
+++ b/zk_toolbox/crates/zk_inception/src/commands/chain/genesis/database.rs
@@ -5,33 +5,26 @@ use common::{
     config::global_config,
     db::{drop_db_if_exists, init_db, migrate_db, DatabaseConfig},
     logger,
-    server::{Server, ServerMode},
-    spinner::Spinner,
 };
 use config::{
     override_config, set_databases, set_file_artifacts, set_rocks_db_config,
-    traits::{FileConfigWithDefaultName, SaveConfigWithBasePath},
-    ChainConfig, ContractsConfig, EcosystemConfig, FileArtifacts, GeneralConfig, GenesisConfig,
-    SecretsConfig, WalletsConfig,
+    traits::SaveConfigWithBasePath, ChainConfig, EcosystemConfig, FileArtifacts,
 };
 use types::ProverMode;
 use xshell::Shell;
 use zksync_basic_types::commitment::L1BatchCommitmentMode;
 
-use super::args::genesis::GenesisArgsFinal;
 use crate::{
-    commands::chain::args::genesis::GenesisArgs,
+    commands::chain::args::genesis::{GenesisArgs, GenesisArgsFinal},
     consts::{
         PATH_TO_ONLY_REAL_PROOFS_OVERRIDE_CONFIG, PATH_TO_VALIDIUM_OVERRIDE_CONFIG,
         PROVER_MIGRATIONS, SERVER_MIGRATIONS,
     },
     messages::{
         MSG_CHAIN_NOT_INITIALIZED, MSG_FAILED_TO_DROP_PROVER_DATABASE_ERR,
-        MSG_FAILED_TO_DROP_SERVER_DATABASE_ERR, MSG_FAILED_TO_RUN_SERVER_ERR,
-        MSG_GENESIS_COMPLETED, MSG_INITIALIZING_DATABASES_SPINNER,
+        MSG_FAILED_TO_DROP_SERVER_DATABASE_ERR, MSG_GENESIS_DATABASES_INITIALIZED,
         MSG_INITIALIZING_PROVER_DATABASE, MSG_INITIALIZING_SERVER_DATABASE,
-        MSG_RECREATE_ROCKS_DB_ERRROR, MSG_SELECTED_CONFIG, MSG_STARTING_GENESIS,
-        MSG_STARTING_GENESIS_SPINNER,
+        MSG_RECREATE_ROCKS_DB_ERRROR,
     },
     utils::rocks_db::{recreate_rocksdb_dirs, RocksDBDirOption},
 };
@@ -41,79 +34,26 @@ pub async fn run(args: GenesisArgs, shell: &Shell) -> anyhow::Result<()> {
     let chain_config = ecosystem_config
         .load_current_chain()
         .context(MSG_CHAIN_NOT_INITIALIZED)?;
-    let args = args.fill_values_with_prompt(&chain_config);
 
-    genesis(args, shell, &chain_config).await?;
-    logger::outro(MSG_GENESIS_COMPLETED);
-
-    Ok(())
-}
-
-pub async fn genesis(
-    args: GenesisArgsFinal,
-    shell: &Shell,
-    config: &ChainConfig,
-) -> anyhow::Result<()> {
-    shell.create_dir(&config.rocks_db_path)?;
-
-    let link_to_code = config.link_to_code.clone();
-    let rocks_db = recreate_rocksdb_dirs(shell, &config.rocks_db_path, RocksDBDirOption::Main)
-        .context(MSG_RECREATE_ROCKS_DB_ERRROR)?;
-    let mut general = config.get_general_config()?;
-    let file_artifacts = FileArtifacts::new(config.artifacts.clone());
-    set_rocks_db_config(&mut general, rocks_db)?;
-    set_file_artifacts(&mut general, file_artifacts);
-    general.save_with_base_path(shell, &config.configs)?;
-
-    if config.prover_version != ProverMode::NoProofs {
-        override_config(
-            shell,
-            link_to_code.join(PATH_TO_ONLY_REAL_PROOFS_OVERRIDE_CONFIG),
-            config,
-        )?;
-    }
-
-    if config.l1_batch_commit_data_generator_mode == L1BatchCommitmentMode::Validium {
-        override_config(
-            shell,
-            link_to_code.join(PATH_TO_VALIDIUM_OVERRIDE_CONFIG),
-            config,
-        )?;
-    }
-
-    let mut secrets = config.get_secrets_config()?;
+    let mut secrets = chain_config.get_secrets_config()?;
+    let args = args.fill_values_with_secrets(&chain_config)?;
     set_databases(&mut secrets, &args.server_db, &args.prover_db)?;
-    secrets.save_with_base_path(shell, &config.configs)?;
-
-    logger::note(
-        MSG_SELECTED_CONFIG,
-        logger::object_to_string(serde_json::json!({
-            "chain_config": config,
-            "server_db_config": args.server_db,
-            "prover_db_config": args.prover_db,
-        })),
-    );
-    logger::info(MSG_STARTING_GENESIS);
+    secrets.save_with_base_path(shell, &chain_config.configs)?;
 
-    let spinner = Spinner::new(MSG_INITIALIZING_DATABASES_SPINNER);
     initialize_databases(
         shell,
         &args.server_db,
         &args.prover_db,
-        config.link_to_code.clone(),
+        chain_config.link_to_code.clone(),
         args.dont_drop,
     )
     .await?;
-    spinner.finish();
-
-    let spinner = Spinner::new(MSG_STARTING_GENESIS_SPINNER);
-    run_server_genesis(config, shell)?;
-    spinner.finish();
+    logger::outro(MSG_GENESIS_DATABASES_INITIALIZED);
 
     Ok(())
 }
 
-async fn initialize_databases(
+pub async fn initialize_databases(
     shell: &Shell,
     server_db_config: &DatabaseConfig,
     prover_db_config: &DatabaseConfig,
@@ -158,18 +98,41 @@ async fn initialize_databases(
     Ok(())
 }
 
-fn run_server_genesis(chain_config: &ChainConfig, shell: &Shell) -> anyhow::Result<()> {
-    let server = Server::new(None, chain_config.link_to_code.clone(), false);
-    server
-        .run(
+pub fn update_configs(
+    args: GenesisArgsFinal,
+    shell: &Shell,
+    config: &ChainConfig,
+) -> anyhow::Result<()> {
+    shell.create_dir(&config.rocks_db_path)?;
+
+    // Update secrets configs
+    let mut secrets = config.get_secrets_config()?;
+    set_databases(&mut secrets, &args.server_db, &args.prover_db)?;
+    secrets.save_with_base_path(shell, &config.configs)?;
+
+    // Update general config
+    let mut general = config.get_general_config()?;
+    let rocks_db = recreate_rocksdb_dirs(shell, &config.rocks_db_path, RocksDBDirOption::Main)
+        .context(MSG_RECREATE_ROCKS_DB_ERRROR)?;
+    let file_artifacts = FileArtifacts::new(config.artifacts.clone());
+    set_rocks_db_config(&mut general, rocks_db)?;
+    set_file_artifacts(&mut general, file_artifacts);
+    general.save_with_base_path(shell, &config.configs)?;
+
+    let link_to_code = config.link_to_code.clone();
+    if config.prover_version != ProverMode::NoProofs {
+        override_config(
+            shell,
+            link_to_code.join(PATH_TO_ONLY_REAL_PROOFS_OVERRIDE_CONFIG),
+            config,
+        )?;
+    }
+    if config.l1_batch_commit_data_generator_mode == L1BatchCommitmentMode::Validium {
+        override_config(
             shell,
-            ServerMode::Genesis,
-            GenesisConfig::get_path_with_base_path(&chain_config.configs),
-            WalletsConfig::get_path_with_base_path(&chain_config.configs),
-            GeneralConfig::get_path_with_base_path(&chain_config.configs),
-            SecretsConfig::get_path_with_base_path(&chain_config.configs),
-            ContractsConfig::get_path_with_base_path(&chain_config.configs),
-            vec![],
-        )
-        .context(MSG_FAILED_TO_RUN_SERVER_ERR)
+            link_to_code.join(PATH_TO_VALIDIUM_OVERRIDE_CONFIG),
+            config,
+        )?;
+    }
+    Ok(())
 }
diff --git a/zk_toolbox/crates/zk_inception/src/commands/chain/genesis/mod.rs b/zk_toolbox/crates/zk_inception/src/commands/chain/genesis/mod.rs
new file mode 100644
index 000000000000..01842c2916ae
--- /dev/null
+++ b/zk_toolbox/crates/zk_inception/src/commands/chain/genesis/mod.rs
@@ -0,0 +1,94 @@
+use anyhow::Context;
+use clap::{command, Parser, Subcommand};
+use common::{logger, spinner::Spinner};
+use config::{ChainConfig, EcosystemConfig};
+use xshell::Shell;
+
+use crate::{
+    commands::chain::{
+        args::genesis::{GenesisArgs, GenesisArgsFinal},
+        genesis::{self, database::initialize_databases, server::run_server_genesis},
+    },
+    messages::{
+        MSG_CHAIN_NOT_INITIALIZED, MSG_GENESIS_COMPLETED, MSG_INITIALIZING_DATABASES_SPINNER,
+        MSG_SELECTED_CONFIG, MSG_STARTING_GENESIS, MSG_STARTING_GENESIS_SPINNER,
+    },
+};
+
+// Genesis subcommands
+pub mod database;
+pub mod server;
+
+#[derive(Subcommand, Debug, Clone)]
+pub enum GenesisSubcommands {
+    /// Initialize databases
+    #[command(alias = "database")]
+    InitDatabase(Box<GenesisArgs>),
+    /// Runs server genesis
+    Server,
+}
+
+#[derive(Parser, Debug)]
+#[command()]
+pub struct GenesisCommand {
+    #[command(subcommand)]
+    command: Option<GenesisSubcommands>,
+    #[clap(flatten)]
+    args: GenesisArgs,
+}
+
+pub(crate) async fn run(args: GenesisCommand, shell: &Shell) -> anyhow::Result<()> {
+    match args.command {
+        Some(GenesisSubcommands::InitDatabase(args)) => database::run(*args, shell).await,
+        Some(GenesisSubcommands::Server) => server::run(shell).await,
+        None => run_genesis(args.args, shell).await,
+    }
+}
+
+pub async fn run_genesis(args: GenesisArgs, shell: &Shell) -> anyhow::Result<()> {
+    let ecosystem_config = EcosystemConfig::from_file(shell)?;
+    let chain_config = ecosystem_config
+        .load_current_chain()
+        .context(MSG_CHAIN_NOT_INITIALIZED)?;
+    let args = args.fill_values_with_prompt(&chain_config);
+
+    genesis(args, shell, &chain_config).await?;
+    logger::outro(MSG_GENESIS_COMPLETED);
+
+    Ok(())
+}
+
+pub async fn genesis(
+    args: GenesisArgsFinal,
+    shell: &Shell,
+    config: &ChainConfig,
+) -> anyhow::Result<()> {
+    genesis::database::update_configs(args.clone(), shell, config)?;
+
+    logger::note(
+        MSG_SELECTED_CONFIG,
+        logger::object_to_string(serde_json::json!({
+            "chain_config": config,
+            "server_db_config": args.server_db,
+            "prover_db_config": args.prover_db,
+        })),
+    );
+    logger::info(MSG_STARTING_GENESIS);
+
+    let spinner = Spinner::new(MSG_INITIALIZING_DATABASES_SPINNER);
+    initialize_databases(
+        shell,
+        &args.server_db,
+        &args.prover_db,
+        config.link_to_code.clone(),
+        args.dont_drop,
+    )
+    .await?;
+    spinner.finish();
+
+    let spinner = Spinner::new(MSG_STARTING_GENESIS_SPINNER);
+    run_server_genesis(config, shell)?;
+    spinner.finish();
+
+    Ok(())
+}
diff --git a/zk_toolbox/crates/zk_inception/src/commands/chain/genesis/server.rs b/zk_toolbox/crates/zk_inception/src/commands/chain/genesis/server.rs
new file mode 100644
index 000000000000..50a74b7ea9e4
--- /dev/null
+++ b/zk_toolbox/crates/zk_inception/src/commands/chain/genesis/server.rs
@@ -0,0 +1,46 @@
+use anyhow::Context;
+use common::{
+    logger,
+    server::{Server, ServerMode},
+    spinner::Spinner,
+};
+use config::{
+    traits::FileConfigWithDefaultName, ChainConfig, ContractsConfig, EcosystemConfig,
+    GeneralConfig, GenesisConfig, SecretsConfig, WalletsConfig,
+};
+use xshell::Shell;
+
+use crate::messages::{
+    MSG_CHAIN_NOT_INITIALIZED, MSG_FAILED_TO_RUN_SERVER_ERR, MSG_GENESIS_COMPLETED,
+    MSG_STARTING_GENESIS_SPINNER,
+};
+
+pub async fn run(shell: &Shell) -> anyhow::Result<()> {
+    let ecosystem_config = EcosystemConfig::from_file(shell)?;
+    let chain_config = ecosystem_config
+        .load_current_chain()
+        .context(MSG_CHAIN_NOT_INITIALIZED)?;
+
+    let spinner = Spinner::new(MSG_STARTING_GENESIS_SPINNER);
+    run_server_genesis(&chain_config, shell)?;
+    spinner.finish();
+    logger::outro(MSG_GENESIS_COMPLETED);
+
+    Ok(())
+}
+
+pub fn run_server_genesis(chain_config: &ChainConfig, shell: &Shell) -> anyhow::Result<()> {
+    let server = Server::new(None, chain_config.link_to_code.clone(), false);
+    server
+        .run(
+            shell,
+            ServerMode::Genesis,
+            GenesisConfig::get_path_with_base_path(&chain_config.configs),
+            WalletsConfig::get_path_with_base_path(&chain_config.configs),
+            GeneralConfig::get_path_with_base_path(&chain_config.configs),
+            SecretsConfig::get_path_with_base_path(&chain_config.configs),
+            ContractsConfig::get_path_with_base_path(&chain_config.configs),
+            vec![],
+        )
+        .context(MSG_FAILED_TO_RUN_SERVER_ERR)
+}
diff --git a/zk_toolbox/crates/zk_inception/src/commands/chain/init/configs.rs b/zk_toolbox/crates/zk_inception/src/commands/chain/init/configs.rs
new file mode 100644
index 000000000000..e6b9fa7117d4
--- /dev/null
+++ b/zk_toolbox/crates/zk_inception/src/commands/chain/init/configs.rs
@@ -0,0 +1,107 @@
+use anyhow::Context;
+use common::logger;
+use config::{
+    copy_configs, set_l1_rpc_url, update_from_chain_config,
+    ChainConfig, ContractsConfig, EcosystemConfig,
+    traits::SaveConfigWithBasePath,
+    DEFAULT_CONSENSUS_PORT,
+};
+use ethers::types::Address;
+use xshell::Shell;
+
+use crate::{
+    commands::{
+        chain::{
+            args::init::configs::{InitConfigsArgs, InitConfigsArgsFinal},
+            genesis,
+        },
+        portal::update_portal_config,
+    },
+    defaults::PORT_RANGE_END,
+    messages::{
+        MSG_CHAIN_CONFIGS_INITIALIZED, MSG_CHAIN_NOT_FOUND_ERR,
+        MSG_PORTAL_FAILED_TO_CREATE_CONFIG_ERR,
+    },
+    utils::{
+        consensus::{generate_consensus_keys, get_consensus_config, get_consensus_secrets},
+        ports::EcosystemPortsScanner,
+    },
+};
+
+pub async fn run(args: InitConfigsArgs, shell: &Shell) -> anyhow::Result<()> {
+    let ecosystem_config = EcosystemConfig::from_file(shell)?;
+    let chain_config = ecosystem_config
+        .load_current_chain()
+        .context(MSG_CHAIN_NOT_FOUND_ERR)?;
+    let args = args.fill_values_with_prompt(&chain_config);
+
+    init_configs(&args, shell, &ecosystem_config, &chain_config).await?;
+    logger::outro(MSG_CHAIN_CONFIGS_INITIALIZED);
+
+    Ok(())
+}
+
+pub async fn init_configs(
+    init_args: &InitConfigsArgsFinal,
+    shell: &Shell,
+    ecosystem_config: &EcosystemConfig,
+    chain_config: &ChainConfig,
+) -> anyhow::Result<ContractsConfig> {
+    // Port scanner should run before copying configs to avoid marking initial ports as assigned
+    let mut ecosystem_ports = EcosystemPortsScanner::scan(shell)?;
+    copy_configs(shell, &ecosystem_config.link_to_code, &chain_config.configs)?;
+
+    if !init_args.no_port_reallocation {
+        ecosystem_ports.allocate_ports_in_yaml(
+            shell,
+            &chain_config.path_to_general_config(),
+            chain_config.id,
+        )?;
+    }
+
+    // Initialize general config
+    let mut general_config = chain_config.get_general_config()?;
+
+    // TODO: This is a temporary solution. We should allocate consensus port using `EcosystemPorts::allocate_ports_in_yaml`
+    let offset = ((chain_config.id - 1) * 100) as u16;
+    let consensus_port_range = DEFAULT_CONSENSUS_PORT + offset..PORT_RANGE_END;
+    let consensus_port =
+        ecosystem_ports.allocate_port(consensus_port_range, "Consensus".to_string())?;
+
+    let consensus_keys = generate_consensus_keys();
+    let consensus_config = get_consensus_config(
+        chain_config,
+        consensus_port,
+        Some(consensus_keys.clone()),
+        None,
+    )?;
+    general_config.consensus_config = Some(consensus_config);
+    general_config.save_with_base_path(shell, &chain_config.configs)?;
+
+    // Initialize genesis config
+    let mut genesis_config = chain_config.get_genesis_config()?;
+    update_from_chain_config(&mut genesis_config, chain_config);
+    genesis_config.save_with_base_path(shell, &chain_config.configs)?;
+
+    // Initialize contracts config
+    let mut contracts_config = ecosystem_config.get_contracts_config()?;
+    contracts_config.l1.diamond_proxy_addr = Address::zero();
+    contracts_config.l1.governance_addr = Address::zero();
+    contracts_config.l1.chain_admin_addr = Address::zero();
+    contracts_config.l1.base_token_addr = chain_config.base_token.address;
+    contracts_config.save_with_base_path(shell, &chain_config.configs)?;
+
+    // Initialize secrets config
+    let mut secrets = chain_config.get_secrets_config()?;
+    set_l1_rpc_url(&mut secrets, init_args.l1_rpc_url.clone())?;
+    secrets.consensus = Some(get_consensus_secrets(&consensus_keys));
+    secrets.save_with_base_path(shell, &chain_config.configs)?;
+
+    genesis::database::update_configs(init_args.genesis_args.clone(), shell, chain_config)?;
+
+    update_portal_config(shell, chain_config)
+        .await
+        .context(MSG_PORTAL_FAILED_TO_CREATE_CONFIG_ERR)?;
+
+    Ok(contracts_config)
+}
diff --git a/zk_toolbox/crates/zk_inception/src/commands/chain/init.rs b/zk_toolbox/crates/zk_inception/src/commands/chain/init/mod.rs
similarity index 55%
rename from zk_toolbox/crates/zk_inception/src/commands/chain/init.rs
rename to zk_toolbox/crates/zk_inception/src/commands/chain/init/mod.rs
index 4d7096723da2..8a36f4e32b2f 100644
--- a/zk_toolbox/crates/zk_inception/src/commands/chain/init.rs
+++ b/zk_toolbox/crates/zk_inception/src/commands/chain/init/mod.rs
@@ -1,106 +1,91 @@
 use anyhow::Context;
+use clap::{command, Parser, Subcommand};
 use common::{git, logger, spinner::Spinner};
-use config::{
-    copy_configs, set_l1_rpc_url, traits::SaveConfigWithBasePath, update_from_chain_config,
-    ChainConfig, EcosystemConfig, DEFAULT_CONSENSUS_PORT,
-};
+use config::{traits::SaveConfigWithBasePath, ChainConfig, EcosystemConfig};
 use types::BaseToken;
 use xshell::Shell;
 
-use super::common::{distribute_eth, mint_base_token, register_chain};
 use crate::{
     accept_ownership::accept_admin,
-    commands::{
-        chain::{
-            args::init::{InitArgs, InitArgsFinal},
-            deploy_l2_contracts, deploy_paymaster,
-            genesis::genesis,
-            set_token_multiplier_setter::set_token_multiplier_setter,
-            setup_legacy_bridge::setup_legacy_bridge,
+    commands::chain::{
+        args::init::{
+            configs::{InitConfigsArgs, InitConfigsArgsFinal},
+            InitArgs, InitArgsFinal,
         },
-        portal::update_portal_config,
+        common::{distribute_eth, mint_base_token},
+        deploy_l2_contracts, deploy_paymaster,
+        genesis::genesis,
+        init::configs::init_configs,
+        register_chain::register_chain,
+        set_token_multiplier_setter::set_token_multiplier_setter,
+        setup_legacy_bridge::setup_legacy_bridge,
     },
-    defaults::PORT_RANGE_END,
     messages::{
         msg_initializing_chain, MSG_ACCEPTING_ADMIN_SPINNER, MSG_CHAIN_INITIALIZED,
         MSG_CHAIN_NOT_FOUND_ERR, MSG_DEPLOYING_PAYMASTER, MSG_GENESIS_DATABASE_ERR,
-        MSG_PORTAL_FAILED_TO_CREATE_CONFIG_ERR, MSG_REGISTERING_CHAIN_SPINNER, MSG_SELECTED_CONFIG,
+        MSG_REGISTERING_CHAIN_SPINNER, MSG_SELECTED_CONFIG,
         MSG_UPDATING_TOKEN_MULTIPLIER_SETTER_SPINNER, MSG_WALLET_TOKEN_MULTIPLIER_SETTER_NOT_FOUND,
     },
-    utils::{
-        consensus::{generate_consensus_keys, get_consensus_config, get_consensus_secrets},
-        ports::EcosystemPortsScanner,
-    },
 };
 
-pub(crate) async fn run(args: InitArgs, shell: &Shell) -> anyhow::Result<()> {
+// Init subcommands
+pub mod configs;
+
+#[derive(Subcommand, Debug, Clone)]
+pub enum ChainInitSubcommands {
+    /// Initialize chain configs
+    Configs(InitConfigsArgs),
+}
+
+#[derive(Parser, Debug)]
+#[command()]
+pub struct ChainInitCommand {
+    #[command(subcommand)]
+    command: Option<ChainInitSubcommands>,
+    #[clap(flatten)]
+    args: InitArgs,
+}
+
+pub(crate) async fn run(args: ChainInitCommand, shell: &Shell) -> anyhow::Result<()> {
+    match args.command {
+        Some(ChainInitSubcommands::Configs(args)) => configs::run(args, shell).await,
+        None => run_init(args.args, shell).await,
+    }
+}
+
+async fn run_init(args: InitArgs, shell: &Shell) -> anyhow::Result<()> {
     let config = EcosystemConfig::from_file(shell)?;
     let chain_config = config
         .load_current_chain()
         .context(MSG_CHAIN_NOT_FOUND_ERR)?;
-    let mut args = args.fill_values_with_prompt(&chain_config);
+    let args = args.fill_values_with_prompt(&chain_config);
 
     logger::note(MSG_SELECTED_CONFIG, logger::object_to_string(&chain_config));
     logger::info(msg_initializing_chain(""));
     git::submodule_update(shell, config.link_to_code.clone())?;
 
-    init(&mut args, shell, &config, &chain_config).await?;
+    init(&args, shell, &config, &chain_config).await?;
 
     logger::success(MSG_CHAIN_INITIALIZED);
     Ok(())
 }
 
 pub async fn init(
-    init_args: &mut InitArgsFinal,
+    init_args: &InitArgsFinal,
     shell: &Shell,
     ecosystem_config: &EcosystemConfig,
     chain_config: &ChainConfig,
 ) -> anyhow::Result<()> {
-    let mut ecosystem_ports = EcosystemPortsScanner::scan(shell)?;
-    copy_configs(shell, &ecosystem_config.link_to_code, &chain_config.configs)?;
-
-    if !init_args.no_port_reallocation {
-        ecosystem_ports.allocate_ports_in_yaml(
-            shell,
-            &chain_config.path_to_general_config(),
-            chain_config.id,
-        )?;
-    }
-    let mut general_config = chain_config.get_general_config()?;
-
-    // TODO: This is a temporary solution. We should allocate consensus port using `EcosystemPorts::allocate_ports_in_yaml`
-    let offset = ((chain_config.id - 1) * 100) as u16;
-    let consensus_port_range = DEFAULT_CONSENSUS_PORT + offset..PORT_RANGE_END;
-    let consensus_port =
-        ecosystem_ports.allocate_port(consensus_port_range, "Consensus".to_string())?;
-
-    let consensus_keys = generate_consensus_keys();
-    let consensus_config = get_consensus_config(
-        chain_config,
-        consensus_port,
-        Some(consensus_keys.clone()),
-        None,
-    )?;
-    general_config.consensus_config = Some(consensus_config);
-    general_config.save_with_base_path(shell, &chain_config.configs)?;
-
-    let mut genesis_config = chain_config.get_genesis_config()?;
-    update_from_chain_config(&mut genesis_config, chain_config);
-    genesis_config.save_with_base_path(shell, &chain_config.configs)?;
-
-    // Copy ecosystem contracts
-    let mut contracts_config = ecosystem_config.get_contracts_config()?;
-    contracts_config.l1.base_token_addr = chain_config.base_token.address;
-    contracts_config.save_with_base_path(shell, &chain_config.configs)?;
-
+    // Initialize configs
+    let init_configs_args = InitConfigsArgsFinal::from_chain_init_args(init_args);
+    let mut contracts_config =
+        init_configs(&init_configs_args, shell, ecosystem_config, chain_config).await?;
+        
+    // Fund some wallet addresses with ETH or base token (only for Localhost)
     distribute_eth(ecosystem_config, chain_config, init_args.l1_rpc_url.clone()).await?;
     mint_base_token(ecosystem_config, chain_config, init_args.l1_rpc_url.clone()).await?;
 
-    let mut secrets = chain_config.get_secrets_config()?;
-    set_l1_rpc_url(&mut secrets, init_args.l1_rpc_url.clone())?;
-    secrets.consensus = Some(get_consensus_secrets(&consensus_keys));
-    secrets.save_with_base_path(shell, &chain_config.configs)?;
-
+    // Register chain on BridgeHub (run by L1 Governor)
     let spinner = Spinner::new(MSG_REGISTERING_CHAIN_SPINNER);
     register_chain(
         shell,
@@ -115,6 +100,8 @@ pub async fn init(
     .await?;
     contracts_config.save_with_base_path(shell, &chain_config.configs)?;
     spinner.finish();
+
+    // Accept ownership for DiamondProxy (run by L2 Governor)
     let spinner = Spinner::new(MSG_ACCEPTING_ADMIN_SPINNER);
     accept_admin(
         shell,
@@ -128,6 +115,7 @@ pub async fn init(
     .await?;
     spinner.finish();
 
+    // Set token multiplier setter address (run by L2 Governor)
     if chain_config.base_token != BaseToken::eth() {
         let spinner = Spinner::new(MSG_UPDATING_TOKEN_MULTIPLIER_SETTER_SPINNER);
         set_token_multiplier_setter(
@@ -148,6 +136,7 @@ pub async fn init(
         spinner.finish();
     }
 
+    // Deploy L2 contracts: L2SharedBridge, L2DefaultUpgrader, ... (run by L1 Governor)
     deploy_l2_contracts::deploy_l2_contracts(
         shell,
         chain_config,
@@ -158,6 +147,7 @@ pub async fn init(
     .await?;
     contracts_config.save_with_base_path(shell, &chain_config.configs)?;
 
+    // Setup legacy bridge - shouldn't be used for new chains (run by L1 Governor)
     if let Some(true) = chain_config.legacy_bridge {
         setup_legacy_bridge(
             shell,
@@ -169,6 +159,7 @@ pub async fn init(
         .await?;
     }
 
+    // Deploy Paymaster contract (run by L2 Governor)
     if init_args.deploy_paymaster {
         let spinner = Spinner::new(MSG_DEPLOYING_PAYMASTER);
         deploy_paymaster::deploy_paymaster(
@@ -187,10 +178,6 @@ pub async fn init(
     genesis(init_args.genesis_args.clone(), shell, chain_config)
         .await
         .context(MSG_GENESIS_DATABASE_ERR)?;
-
-    update_portal_config(shell, chain_config)
-        .await
-        .context(MSG_PORTAL_FAILED_TO_CREATE_CONFIG_ERR)?;
-
+    
     Ok(())
 }
diff --git a/zk_toolbox/crates/zk_inception/src/commands/chain/mod.rs b/zk_toolbox/crates/zk_inception/src/commands/chain/mod.rs
index 4ddc4bf58569..378309a07cb1 100644
--- a/zk_toolbox/crates/zk_inception/src/commands/chain/mod.rs
+++ b/zk_toolbox/crates/zk_inception/src/commands/chain/mod.rs
@@ -1,15 +1,16 @@
 use ::common::forge::ForgeScriptArgs;
 use args::build_transactions::BuildTransactionsArgs;
 pub(crate) use args::create::ChainCreateArgsFinal;
-use clap::Subcommand;
+use clap::{command, Subcommand};
 pub(crate) use create::create_chain_inner;
 use xshell::Shell;
 
 use crate::commands::chain::{
-    args::{create::ChainCreateArgs, genesis::GenesisArgs, init::InitArgs},
-    deploy_l2_contracts::Deploy2ContractsOption,
+    args::create::ChainCreateArgs, deploy_l2_contracts::Deploy2ContractsOption,
+    genesis::GenesisCommand, init::ChainInitCommand,
 };
 
+mod accept_chain_ownership;
 pub(crate) mod args;
 mod build_transactions;
 mod common;
@@ -17,7 +18,8 @@ mod create;
 pub mod deploy_l2_contracts;
 pub mod deploy_paymaster;
 pub mod genesis;
-pub(crate) mod init;
+pub mod init;
+pub mod register_chain;
 mod set_token_multiplier_setter;
 mod setup_legacy_bridge;
 
@@ -28,20 +30,32 @@ pub enum ChainCommands {
     /// Create unsigned transactions for chain deployment
     BuildTransactions(BuildTransactionsArgs),
     /// Initialize chain, deploying necessary contracts and performing on-chain operations
-    Init(InitArgs),
+    Init(Box<ChainInitCommand>),
     /// Run server genesis
-    Genesis(GenesisArgs),
-    /// Initialize bridges on l2
-    #[command(alias = "bridge")]
-    InitializeBridges(ForgeScriptArgs),
-    /// Deploy all l2 contracts
+    Genesis(GenesisCommand),
+    /// Register a new chain on L1 (executed by L1 governor).
+    /// This command deploys and configures Governance, ChainAdmin, and DiamondProxy contracts,
+    /// registers chain with BridgeHub and sets pending admin for DiamondProxy.
+    /// Note: After completion, L2 governor can accept ownership by running `accept-chain-ownership`
+    #[command(alias = "register")]
+    RegisterChain(ForgeScriptArgs),
+    /// Deploy all L2 contracts (executed by L1 governor).
     #[command(alias = "l2")]
     DeployL2Contracts(ForgeScriptArgs),
+    /// Accept ownership of L2 chain (executed by L2 governor).
+    /// This command should be run after `register-chain` to accept ownership of newly created
+    /// DiamondProxy contract.
+    #[command(alias = "accept-ownership")]
+    AcceptChainOwnership(ForgeScriptArgs),
+    /// Initialize bridges on L2
+    #[command(alias = "bridge")]
+    InitializeBridges(ForgeScriptArgs),
     /// Deploy L2 consensus registry
     #[command(alias = "consensus")]
     DeployConsensusRegistry(ForgeScriptArgs),
     /// Deploy Default Upgrader
-    Upgrader(ForgeScriptArgs),
+    #[command(alias = "upgrader")]
+    DeployUpgrader(ForgeScriptArgs),
     /// Deploy paymaster smart contract
     #[command(alias = "paymaster")]
     DeployPaymaster(ForgeScriptArgs),
@@ -52,16 +66,18 @@ pub enum ChainCommands {
 pub(crate) async fn run(shell: &Shell, args: ChainCommands) -> anyhow::Result<()> {
     match args {
         ChainCommands::Create(args) => create::run(args, shell),
-        ChainCommands::Init(args) => init::run(args, shell).await,
+        ChainCommands::Init(args) => init::run(*args, shell).await,
         ChainCommands::BuildTransactions(args) => build_transactions::run(args, shell).await,
         ChainCommands::Genesis(args) => genesis::run(args, shell).await,
+        ChainCommands::RegisterChain(args) => register_chain::run(args, shell).await,
         ChainCommands::DeployL2Contracts(args) => {
             deploy_l2_contracts::run(args, shell, Deploy2ContractsOption::All).await
         }
+        ChainCommands::AcceptChainOwnership(args) => accept_chain_ownership::run(args, shell).await,
         ChainCommands::DeployConsensusRegistry(args) => {
             deploy_l2_contracts::run(args, shell, Deploy2ContractsOption::ConsensusRegistry).await
         }
-        ChainCommands::Upgrader(args) => {
+        ChainCommands::DeployUpgrader(args) => {
             deploy_l2_contracts::run(args, shell, Deploy2ContractsOption::Upgrader).await
         }
         ChainCommands::InitializeBridges(args) => {
diff --git a/zk_toolbox/crates/zk_inception/src/commands/chain/register_chain.rs b/zk_toolbox/crates/zk_inception/src/commands/chain/register_chain.rs
new file mode 100644
index 000000000000..9f2ff41f897e
--- /dev/null
+++ b/zk_toolbox/crates/zk_inception/src/commands/chain/register_chain.rs
@@ -0,0 +1,96 @@
+use anyhow::Context;
+use common::{
+    forge::{Forge, ForgeScriptArgs},
+    logger,
+    spinner::Spinner,
+};
+use config::{
+    forge_interface::{
+        register_chain::{input::RegisterChainL1Config, output::RegisterChainOutput},
+        script_params::REGISTER_CHAIN_SCRIPT_PARAMS,
+    },
+    traits::{ReadConfig, SaveConfig, SaveConfigWithBasePath},
+    ChainConfig, ContractsConfig, EcosystemConfig,
+};
+use xshell::Shell;
+
+use crate::{
+    messages::{
+        MSG_CHAIN_NOT_INITIALIZED, MSG_CHAIN_REGISTERED, MSG_L1_SECRETS_MUST_BE_PRESENTED,
+        MSG_REGISTERING_CHAIN_SPINNER,
+    },
+    utils::forge::{check_the_balance, fill_forge_private_key},
+};
+
+pub async fn run(args: ForgeScriptArgs, shell: &Shell) -> anyhow::Result<()> {
+    let ecosystem_config = EcosystemConfig::from_file(shell)?;
+    let chain_config = ecosystem_config
+        .load_current_chain()
+        .context(MSG_CHAIN_NOT_INITIALIZED)?;
+    let mut contracts = chain_config.get_contracts_config()?;
+    let secrets = chain_config.get_secrets_config()?;
+    let l1_rpc_url = secrets
+        .l1
+        .context(MSG_L1_SECRETS_MUST_BE_PRESENTED)?
+        .l1_rpc_url
+        .expose_str()
+        .to_string();
+    let spinner = Spinner::new(MSG_REGISTERING_CHAIN_SPINNER);
+    register_chain(
+        shell,
+        args,
+        &ecosystem_config,
+        &chain_config,
+        &mut contracts,
+        l1_rpc_url,
+        None,
+        true,
+    )
+    .await?;
+    contracts.save_with_base_path(shell, chain_config.configs)?;
+    spinner.finish();
+    logger::success(MSG_CHAIN_REGISTERED);
+    Ok(())
+}
+
+#[allow(clippy::too_many_arguments)]
+pub async fn register_chain(
+    shell: &Shell,
+    forge_args: ForgeScriptArgs,
+    config: &EcosystemConfig,
+    chain_config: &ChainConfig,
+    contracts: &mut ContractsConfig,
+    l1_rpc_url: String,
+    sender: Option<String>,
+    broadcast: bool,
+) -> anyhow::Result<()> {
+    let deploy_config_path = REGISTER_CHAIN_SCRIPT_PARAMS.input(&config.link_to_code);
+
+    let deploy_config = RegisterChainL1Config::new(chain_config, contracts)?;
+    deploy_config.save(shell, deploy_config_path)?;
+
+    let mut forge = Forge::new(&config.path_to_foundry())
+        .script(&REGISTER_CHAIN_SCRIPT_PARAMS.script(), forge_args.clone())
+        .with_ffi()
+        .with_rpc_url(l1_rpc_url);
+
+    if broadcast {
+        forge = forge.with_broadcast();
+    }
+
+    if let Some(address) = sender {
+        forge = forge.with_sender(address);
+    } else {
+        forge = fill_forge_private_key(forge, config.get_wallets()?.governor_private_key())?;
+        check_the_balance(&forge).await?;
+    }
+
+    forge.run(shell)?;
+
+    let register_chain_output = RegisterChainOutput::read(
+        shell,
+        REGISTER_CHAIN_SCRIPT_PARAMS.output(&chain_config.link_to_code),
+    )?;
+    contracts.set_chain_contracts(&register_chain_output);
+    Ok(())
+}
diff --git a/zk_toolbox/crates/zk_inception/src/commands/ecosystem/args/init.rs b/zk_toolbox/crates/zk_inception/src/commands/ecosystem/args/init.rs
index 7898f8d254a8..6d6ed2f3fd9e 100644
--- a/zk_toolbox/crates/zk_inception/src/commands/ecosystem/args/init.rs
+++ b/zk_toolbox/crates/zk_inception/src/commands/ecosystem/args/init.rs
@@ -10,10 +10,10 @@ use crate::{
     commands::chain::args::genesis::GenesisArgs,
     defaults::LOCAL_RPC_URL,
     messages::{
-        MSG_DEPLOY_ECOSYSTEM_PROMPT, MSG_DEPLOY_ERC20_PROMPT, MSG_DEPLOY_PAYMASTER_PROMPT,
-        MSG_DEV_ARG_HELP, MSG_GENESIS_ARGS_HELP, MSG_L1_RPC_URL_HELP, MSG_L1_RPC_URL_INVALID_ERR,
-        MSG_L1_RPC_URL_PROMPT, MSG_NO_PORT_REALLOCATION_HELP, MSG_OBSERVABILITY_HELP,
-        MSG_OBSERVABILITY_PROMPT,
+        MSG_DEPLOY_ECOSYSTEM_PROMPT, MSG_DEPLOY_ERC20_PROMPT, MSG_DEV_ARG_HELP,
+        MSG_GENESIS_ARGS_HELP, MSG_L1_RPC_URL_HELP, MSG_L1_RPC_URL_INVALID_ERR,
+        MSG_L1_RPC_URL_PROMPT, MSG_OBSERVABILITY_HELP, MSG_OBSERVABILITY_PROMPT,
+        MSG_NO_PORT_REALLOCATION_HELP,
     },
 };
 
@@ -74,9 +74,6 @@ pub struct EcosystemArgsFinal {
 
 #[derive(Debug, Clone, Serialize, Deserialize, Parser)]
 pub struct EcosystemInitArgs {
-    /// Deploy Paymaster contract
-    #[clap(long, default_missing_value = "true", num_args = 0..=1)]
-    pub deploy_paymaster: Option<bool>,
     /// Deploy ERC20 contracts
     #[clap(long, default_missing_value = "true", num_args = 0..=1)]
     pub deploy_erc20: Option<bool>,
@@ -86,9 +83,15 @@ pub struct EcosystemInitArgs {
     #[clap(flatten)]
     #[serde(flatten)]
     pub forge_args: ForgeScriptArgs,
+    /// Deploy Paymaster contract
+    #[clap(long, default_missing_value = "true", num_args = 0..=1)]
+    pub deploy_paymaster: Option<bool>,
     #[clap(flatten, next_help_heading = MSG_GENESIS_ARGS_HELP)]
     #[serde(flatten)]
     pub genesis_args: GenesisArgs,
+    /// Initialize ecosystem only and skip chain initialization (chain can be initialized later with `chain init` subcommand)
+    #[clap(long, default_value_t = false)]
+    pub ecosystem_only: bool,
     #[clap(long, help = MSG_DEV_ARG_HELP)]
     pub dev: bool,
     #[clap(long, short = 'o', help = MSG_OBSERVABILITY_HELP, default_missing_value = "true", num_args = 0..=1)]
@@ -99,20 +102,14 @@ pub struct EcosystemInitArgs {
 
 impl EcosystemInitArgs {
     pub fn fill_values_with_prompt(self, l1_network: L1Network) -> EcosystemInitArgsFinal {
-        let (deploy_paymaster, deploy_erc20) = if self.dev {
-            (true, true)
+        let deploy_erc20 = if self.dev {
+            true
         } else {
-            let deploy_paymaster = self.deploy_paymaster.unwrap_or_else(|| {
-                PromptConfirm::new(MSG_DEPLOY_PAYMASTER_PROMPT)
-                    .default(true)
-                    .ask()
-            });
-            let deploy_erc20 = self.deploy_erc20.unwrap_or_else(|| {
+            self.deploy_erc20.unwrap_or_else(|| {
                 PromptConfirm::new(MSG_DEPLOY_ERC20_PROMPT)
                     .default(true)
                     .ask()
-            });
-            (deploy_paymaster, deploy_erc20)
+            })
         };
         let ecosystem = self.ecosystem.fill_values_with_prompt(l1_network, self.dev);
         let observability = if self.dev {
@@ -126,12 +123,12 @@ impl EcosystemInitArgs {
         };
 
         EcosystemInitArgsFinal {
-            deploy_paymaster,
             deploy_erc20,
             ecosystem,
             forge_args: self.forge_args.clone(),
             dev: self.dev,
             observability,
+            ecosystem_only: self.ecosystem_only,
             no_port_reallocation: self.no_port_reallocation,
         }
     }
@@ -139,11 +136,11 @@ impl EcosystemInitArgs {
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct EcosystemInitArgsFinal {
-    pub deploy_paymaster: bool,
     pub deploy_erc20: bool,
     pub ecosystem: EcosystemArgsFinal,
     pub forge_args: ForgeScriptArgs,
     pub dev: bool,
     pub observability: bool,
+    pub ecosystem_only: bool,
     pub no_port_reallocation: bool,
 }
diff --git a/zk_toolbox/crates/zk_inception/src/commands/ecosystem/init.rs b/zk_toolbox/crates/zk_inception/src/commands/ecosystem/init.rs
index 80efc48f732b..67ae31628423 100644
--- a/zk_toolbox/crates/zk_inception/src/commands/ecosystem/init.rs
+++ b/zk_toolbox/crates/zk_inception/src/commands/ecosystem/init.rs
@@ -37,9 +37,8 @@ use crate::{
         },
     },
     messages::{
-        msg_ecosystem_initialized, msg_ecosystem_no_found_preexisting_contract,
-        msg_initializing_chain, MSG_CHAIN_NOT_INITIALIZED,
-        MSG_DEPLOYING_ECOSYSTEM_CONTRACTS_SPINNER, MSG_DEPLOYING_ERC20,
+        msg_chain_load_err, msg_ecosystem_initialized, msg_ecosystem_no_found_preexisting_contract,
+        msg_initializing_chain, MSG_DEPLOYING_ECOSYSTEM_CONTRACTS_SPINNER, MSG_DEPLOYING_ERC20,
         MSG_DEPLOYING_ERC20_SPINNER, MSG_ECOSYSTEM_CONTRACTS_PATH_INVALID_ERR,
         MSG_ECOSYSTEM_CONTRACTS_PATH_PROMPT, MSG_INITIALIZING_ECOSYSTEM,
         MSG_INTALLING_DEPS_SPINNER,
@@ -57,11 +56,9 @@ pub async fn run(args: EcosystemInitArgs, shell: &Shell) -> anyhow::Result<()> {
         Err(_) => create_initial_deployments_config(shell, &ecosystem_config.config)?,
     };
 
-    let mut genesis_args = args.genesis_args.clone();
-    if args.dev {
-        genesis_args.use_default = true;
-    }
-    let mut final_ecosystem_args = args.fill_values_with_prompt(ecosystem_config.l1_network);
+    let mut final_ecosystem_args = args
+        .clone()
+        .fill_values_with_prompt(ecosystem_config.l1_network);
 
     logger::info(MSG_INITIALIZING_ECOSYSTEM);
 
@@ -69,7 +66,7 @@ pub async fn run(args: EcosystemInitArgs, shell: &Shell) -> anyhow::Result<()> {
         setup_observability::run(shell)?;
     }
 
-    let contracts_config = init(
+    let contracts_config = init_ecosystem(
         &mut final_ecosystem_args,
         shell,
         &ecosystem_config,
@@ -94,42 +91,17 @@ pub async fn run(args: EcosystemInitArgs, shell: &Shell) -> anyhow::Result<()> {
         .await?;
     }
 
-    // If the name of chain passed then we deploy exactly this chain otherwise deploy all chains
-    let list_of_chains = if let Some(name) = global_config().chain_name.clone() {
-        vec![name]
-    } else {
-        ecosystem_config.list_of_chains()
-    };
-
-    for chain_name in &list_of_chains {
-        logger::info(msg_initializing_chain(chain_name));
-        let chain_config = ecosystem_config
-            .load_chain(Some(chain_name.clone()))
-            .context(MSG_CHAIN_NOT_INITIALIZED)?;
-
-        let mut chain_init_args = chain::args::init::InitArgsFinal {
-            forge_args: final_ecosystem_args.forge_args.clone(),
-            genesis_args: genesis_args.clone().fill_values_with_prompt(&chain_config),
-            deploy_paymaster: final_ecosystem_args.deploy_paymaster,
-            l1_rpc_url: final_ecosystem_args.ecosystem.l1_rpc_url.clone(),
-            no_port_reallocation: final_ecosystem_args.no_port_reallocation,
-        };
-
-        chain::init::init(
-            &mut chain_init_args,
-            shell,
-            &ecosystem_config,
-            &chain_config,
-        )
-        .await?;
+    // Initialize chain(s)
+    let mut chains: Vec<String> = vec![];
+    if !final_ecosystem_args.ecosystem_only {
+        chains = init_chains(&args, &final_ecosystem_args, shell, &ecosystem_config).await?;
     }
-
-    logger::outro(msg_ecosystem_initialized(&list_of_chains.join(",")));
+    logger::outro(msg_ecosystem_initialized(&chains.join(",")));
 
     Ok(())
 }
 
-async fn init(
+async fn init_ecosystem(
     init_args: &mut EcosystemInitArgsFinal,
     shell: &Shell,
     ecosystem_config: &EcosystemConfig,
@@ -358,3 +330,53 @@ async fn deploy_ecosystem_inner(
 
     Ok(contracts_config)
 }
+
+async fn init_chains(
+    init_args: &EcosystemInitArgs,
+    final_init_args: &EcosystemInitArgsFinal,
+    shell: &Shell,
+    ecosystem_config: &EcosystemConfig,
+) -> anyhow::Result<Vec<String>> {
+    // If the name of chain passed then we deploy exactly this chain otherwise deploy all chains
+    let list_of_chains = if let Some(name) = global_config().chain_name.clone() {
+        vec![name]
+    } else {
+        ecosystem_config.list_of_chains()
+    };
+    // Set default values for dev mode
+    let mut deploy_paymaster = init_args.deploy_paymaster;
+    let mut genesis_args = init_args.genesis_args.clone();
+    if final_init_args.dev {
+        deploy_paymaster = Some(true);
+        genesis_args.use_default = true;
+    }
+    // Can't initialize multiple chains with the same DB
+    if list_of_chains.len() > 1 {
+        genesis_args.reset_db_names();
+    }
+    // Initialize chains
+    for chain_name in &list_of_chains {
+        logger::info(msg_initializing_chain(chain_name));
+        let chain_config = ecosystem_config
+            .load_chain(Some(chain_name.clone()))
+            .context(msg_chain_load_err(chain_name))?;
+
+        let chain_init_args = chain::args::init::InitArgs {
+            forge_args: final_init_args.forge_args.clone(),
+            genesis_args: genesis_args.clone(),
+            deploy_paymaster,
+            l1_rpc_url: Some(final_init_args.ecosystem.l1_rpc_url.clone()),
+            no_port_reallocation: final_init_args.no_port_reallocation
+        };
+        let final_chain_init_args = chain_init_args.fill_values_with_prompt(&chain_config);
+
+        chain::init::init(
+            &final_chain_init_args,
+            shell,
+            ecosystem_config,
+            &chain_config,
+        )
+        .await?;
+    }
+    Ok(list_of_chains)
+}
diff --git a/zk_toolbox/crates/zk_inception/src/main.rs b/zk_toolbox/crates/zk_inception/src/main.rs
index 0af9922d0c41..a305ca053b7c 100644
--- a/zk_toolbox/crates/zk_inception/src/main.rs
+++ b/zk_toolbox/crates/zk_inception/src/main.rs
@@ -42,10 +42,10 @@ struct Inception {
 pub enum InceptionSubcommands {
     /// Ecosystem related commands
     #[command(subcommand, alias = "e")]
-    Ecosystem(EcosystemCommands),
+    Ecosystem(Box<EcosystemCommands>),
     /// Chain related commands
     #[command(subcommand, alias = "c")]
-    Chain(ChainCommands),
+    Chain(Box<ChainCommands>),
     /// Prover related commands
     #[command(subcommand, alias = "p")]
     Prover(ProverCommands),
@@ -121,8 +121,8 @@ async fn main() -> anyhow::Result<()> {
 
 async fn run_subcommand(inception_args: Inception, shell: &Shell) -> anyhow::Result<()> {
     match inception_args.command {
-        InceptionSubcommands::Ecosystem(args) => commands::ecosystem::run(shell, args).await?,
-        InceptionSubcommands::Chain(args) => commands::chain::run(shell, args).await?,
+        InceptionSubcommands::Ecosystem(args) => commands::ecosystem::run(shell, *args).await?,
+        InceptionSubcommands::Chain(args) => commands::chain::run(shell, *args).await?,
         InceptionSubcommands::Prover(args) => commands::prover::run(shell, args).await?,
         InceptionSubcommands::Server(args) => commands::server::run(shell, args)?,
         InceptionSubcommands::Containers(args) => commands::containers::run(shell, args)?,
diff --git a/zk_toolbox/crates/zk_inception/src/messages.rs b/zk_toolbox/crates/zk_inception/src/messages.rs
index 621441ae8d49..ebdcf7378a44 100644
--- a/zk_toolbox/crates/zk_inception/src/messages.rs
+++ b/zk_toolbox/crates/zk_inception/src/messages.rs
@@ -72,6 +72,10 @@ pub(super) const MSG_CHAIN_NOT_FOUND_ERR: &str = "Chain not found";
 pub(super) const MSG_INITIALIZING_ECOSYSTEM: &str = "Initializing ecosystem";
 pub(super) const MSG_DEPLOYING_ERC20: &str = "Deploying ERC20 contracts";
 pub(super) const MSG_CHAIN_INITIALIZED: &str = "Chain initialized successfully";
+pub(super) const MSG_CHAIN_CONFIGS_INITIALIZED: &str = "Chain configs were initialized";
+pub(super) const MSG_CHAIN_OWNERSHIP_TRANSFERRED: &str =
+    "Chain ownership was transferred successfully";
+pub(super) const MSG_CHAIN_REGISTERED: &str = "Chain registraion was successful";
 pub(super) const MSG_DISTRIBUTING_ETH_SPINNER: &str = "Distributing eth...";
 pub(super) const MSG_MINT_BASE_TOKEN_SPINNER: &str =
     "Minting base token to the governance addresses...";
@@ -100,7 +104,11 @@ pub(super) fn msg_initializing_chain(chain_name: &str) -> String {
 }
 
 pub(super) fn msg_ecosystem_initialized(chains: &str) -> String {
-    format!("Ecosystem initialized successfully with chains {chains}")
+    if chains.is_empty() {
+        "Ecosystem initialized successfully. You can initialize chain with `chain init`".to_string()
+    } else {
+        format!("Ecosystem initialized successfully with chains {chains}")
+    }
 }
 
 /// Ecosystem default related messages
@@ -187,6 +195,7 @@ pub(super) const MSG_INITIALIZING_SERVER_DATABASE: &str = "Initializing server d
 pub(super) const MSG_FAILED_TO_DROP_SERVER_DATABASE_ERR: &str = "Failed to drop server database";
 pub(super) const MSG_INITIALIZING_PROVER_DATABASE: &str = "Initializing prover database";
 pub(super) const MSG_FAILED_TO_DROP_PROVER_DATABASE_ERR: &str = "Failed to drop prover database";
+pub(super) const MSG_GENESIS_DATABASES_INITIALIZED: &str = "Databases initialized successfully";
 
 /// Chain update related messages
 pub(super) const MSG_WALLETS_CONFIG_MUST_BE_PRESENT: &str = "Wallets configuration must be present";