diff --git a/Cargo.toml b/Cargo.toml
index e0ac14dd..c7702acd 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -29,16 +29,10 @@ sqlx = { version = "0.7.4", default-features = false }
 bitcoin-mock-rpc = { git = "https://github.com/chainwayxyz/bitcoin-mock-rpc", tag = "v0.0.11" }
 musig2 = { version = "0.0.11", features = ["serde"] }
 
-# Always optimize; building and running the guest takes much longer without optimization.
-[profile.dev]
-opt-level = 3
-
-[profile.dev.build-override]
-opt-level = 3
-
 [profile.release]
-debug = 1
 lto = true
-
-[profile.release.build-override]
-opt-level = 3
+strip = true
+codegen-units = 1
+# TODO: Abort on panic can be enabled to save binary space. But needs a proper
+# error management infrastructure to not lose crash report.
+# panic = "abort"
diff --git a/core/src/aggregator.rs b/core/src/aggregator.rs
index 4aa9a762..0c0bb275 100644
--- a/core/src/aggregator.rs
+++ b/core/src/aggregator.rs
@@ -35,7 +35,7 @@ impl Aggregator {
     #[tracing::instrument(err(level = tracing::Level::ERROR), ret(level = tracing::Level::TRACE))]
     pub async fn new(config: BridgeConfig) -> Result<Self, BridgeError> {
         let nofn_xonly_pk = secp256k1::XOnlyPublicKey::from_musig2_pks(
-            config.verifiers_public_keys.clone(),
+            config.verifier.public_keys.clone(),
             None,
             false,
         );
@@ -62,9 +62,9 @@ impl Aggregator {
             &operator_xonly_pk,
             operator_idx,
             &self.nofn_xonly_pk,
-            self.config.network,
+            self.config.bitcoin.network,
             self.config.user_takes_after,
-            self.config.operator_takes_after,
+            self.config.operator.takes_after,
             self.config.bridge_amount_sats,
         );
         // tracing::debug!("SLASH_OR_TAKE_TX: {:?}", tx);
@@ -73,7 +73,7 @@ impl Aggregator {
             Actor::convert_tx_to_sighash_script_spend(&mut tx, 0, 0)?.to_byte_array();
         // tracing::debug!("aggregate SLASH_OR_TAKE_TX message: {:?}", message);
         let final_sig: [u8; 64] = aggregate_partial_signatures(
-            self.config.verifiers_public_keys.clone(),
+            self.config.verifier.public_keys.clone(),
             None,
             false,
             agg_nonce,
@@ -83,7 +83,7 @@ impl Aggregator {
         // tracing::debug!("aggregate SLASH_OR_TAKE_TX final_sig: {:?}", final_sig);
         // tracing::debug!(
         //     "aggregate SLASH_OR_TAKE_TX for verifiers: {:?}",
-        //     self.config.verifiers_public_keys.clone()
+        //     self.config.verifier.public_keys.clone()
         // );
         // tracing::debug!(
         //     "aggregate SLASH_OR_TAKE_TX for operator: {:?}",
@@ -109,11 +109,11 @@ impl Aggregator {
                 &utils::SECP,
                 *utils::UNSPENDABLE_XONLY_PUBKEY,
                 None,
-                self.config.network,
+                self.config.bitcoin.network,
             )
             .as_unchecked(),
             &self.nofn_xonly_pk,
-            self.config.network,
+            self.config.bitcoin.network,
             self.config.user_takes_after,
             self.config.bridge_amount_sats,
         );
@@ -127,9 +127,9 @@ impl Aggregator {
             operator_xonly_pk,
             operator_idx,
             &self.nofn_xonly_pk,
-            self.config.network,
+            self.config.bitcoin.network,
             self.config.user_takes_after,
-            self.config.operator_takes_after,
+            self.config.operator.takes_after,
             self.config.bridge_amount_sats,
         );
         let slash_or_take_utxo = UTXO {
@@ -149,8 +149,8 @@ impl Aggregator {
             slash_or_take_utxo,
             operator_xonly_pk,
             &self.nofn_xonly_pk,
-            self.config.network,
-            self.config.operator_takes_after,
+            self.config.bitcoin.network,
+            self.config.operator.takes_after,
             self.config.bridge_amount_sats,
             self.config.operator_wallet_addresses[operator_idx].clone(),
         );
@@ -164,7 +164,7 @@ impl Aggregator {
         let message: [u8; 32] =
             Actor::convert_tx_to_sighash_pubkey_spend(&mut tx_handler, 0)?.to_byte_array();
         let final_sig: [u8; 64] = aggregate_partial_signatures(
-            self.config.verifiers_public_keys.clone(),
+            self.config.verifier.public_keys.clone(),
             None,
             true,
             agg_nonce,
@@ -189,7 +189,7 @@ impl Aggregator {
             evm_address,
             recovery_taproot_address,
             &self.nofn_xonly_pk,
-            self.config.network,
+            self.config.bitcoin.network,
             self.config.user_takes_after,
             self.config.bridge_amount_sats,
         );
@@ -198,7 +198,7 @@ impl Aggregator {
         let message: [u8; 32] =
             Actor::convert_tx_to_sighash_script_spend(&mut tx, 0, 0)?.to_byte_array();
         let final_sig: [u8; 64] = aggregate_partial_signatures(
-            self.config.verifiers_public_keys.clone(),
+            self.config.verifier.public_keys.clone(),
             None,
             false,
             agg_nonce,
@@ -255,7 +255,7 @@ impl Aggregator {
             let agg_sig = self.aggregate_slash_or_take_partial_sigs(
                 deposit_outpoint,
                 kickoff_utxos[i].clone(),
-                self.config.operators_xonly_pks[i],
+                self.config.operator.xonly_pks[i],
                 i,
                 &agg_nonces[i].clone(),
                 partial_sigs,
@@ -279,7 +279,7 @@ impl Aggregator {
             let agg_sig = self.aggregate_operator_takes_partial_sigs(
                 deposit_outpoint,
                 kickoff_utxos[i].clone(),
-                &self.config.operators_xonly_pks[i].clone(),
+                &self.config.operator.xonly_pks[i].clone(),
                 i,
                 &agg_nonces[i].clone(),
                 partial_sigs.iter().map(|v| v[i]).collect(),
@@ -314,7 +314,7 @@ impl Aggregator {
             &evm_address,
             &recovery_taproot_address,
             &self.nofn_xonly_pk,
-            self.config.network,
+            self.config.bitcoin.network,
             self.config.user_takes_after,
             self.config.bridge_amount_sats,
         );
diff --git a/core/src/bin/all_servers.rs b/core/src/bin/all_servers.rs
index 1b9f0151..bd7a6812 100644
--- a/core/src/bin/all_servers.rs
+++ b/core/src/bin/all_servers.rs
@@ -27,7 +27,7 @@ async fn main() {
             .join(",")
     );
     let xonly =
-        secp256k1::XOnlyPublicKey::from_musig2_pks(config.verifiers_public_keys, None, false);
+        secp256k1::XOnlyPublicKey::from_musig2_pks(config.verifier.public_keys, None, false);
     println!(
         "AGGREGATOR_URL={}",
         format!("http://127.0.0.1:{}", aggregator.2.port())
diff --git a/core/src/bin/config_generator.rs b/core/src/bin/config_generator.rs
index 10e4f9ab..767ca677 100644
--- a/core/src/bin/config_generator.rs
+++ b/core/src/bin/config_generator.rs
@@ -47,13 +47,16 @@ fn main() {
     for i in 0..num_verifiers {
         let mut new_config = BridgeConfig {
             secret_key: secret_keys[i],
-            verifiers_public_keys: public_keys.clone(),
-            num_verifiers,
+            verifier: clementine_core::config::Verifier {
+                public_keys: public_keys.clone(),
+                count: num_verifiers,
+                ..cur_config.verifier.clone()
+            },
             port: ports[i],
             ..cur_config.clone()
         };
         if i == num_verifiers - 1 {
-            new_config.verifier_endpoints = Some(
+            new_config.verifier.endpoints = Some(
                 ports[0..ports.len() - 1]
                     .iter()
                     .map(|p| format!("http://{}:{}", cur_config.host, p))
diff --git a/core/src/bin/server.rs b/core/src/bin/server.rs
index b2f2822d..1838ca00 100644
--- a/core/src/bin/server.rs
+++ b/core/src/bin/server.rs
@@ -15,9 +15,9 @@ async fn main() {
     }
 
     let rpc = ExtendedRpc::<bitcoincore_rpc::Client>::new(
-        config.bitcoin_rpc_url.clone(),
-        config.bitcoin_rpc_user.clone(),
-        config.bitcoin_rpc_password.clone(),
+        config.bitcoin.rpc_url.clone(),
+        config.bitcoin.rpc_user.clone(),
+        config.bitcoin.rpc_password.clone(),
     );
 
     let database = Database::new(config.clone()).await.unwrap();
diff --git a/core/src/config.rs b/core/src/config.rs
index dfcb6f25..b519f853 100644
--- a/core/src/config.rs
+++ b/core/src/config.rs
@@ -16,75 +16,160 @@ use bitcoin::Network;
 use serde::{Deserialize, Serialize};
 use std::{fs::File, io::Read, path::PathBuf};
 
+/// PostgreSQL database configuration options.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Database {
+    /// PostgreSQL database host address.
+    pub host: String,
+    /// PostgreSQL database port.
+    pub port: usize,
+    /// PostgreSQL database user name.
+    pub user: String,
+    /// PostgreSQL database user password.
+    pub password: String,
+    /// PostgreSQL database name.
+    pub name: String,
+}
+impl Default for Database {
+    fn default() -> Self {
+        Self {
+            host: "127.0.0.1".to_string(),
+            port: 5432,
+            user: "clementine".to_string(),
+            password: "clementine".to_string(),
+            name: "clementine".to_string(),
+        }
+    }
+}
+
+/// Bitcoin connection configuration options.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Bitcoin {
+    /// Butcoin RPC url.
+    pub rpc_url: String,
+    /// Bitcoin RPC user.
+    pub rpc_user: String,
+    /// Bitcoin RPC user password.
+    pub rpc_password: String,
+    /// Bitcoin network to work on.
+    pub network: Network,
+}
+impl Default for Bitcoin {
+    fn default() -> Self {
+        Self {
+            network: Network::Regtest,
+            rpc_url: "http://127.0.0.1:18443".to_string(),
+            rpc_user: "admin".to_string(),
+            rpc_password: "admin".to_string(),
+        }
+    }
+}
+
+/// Operator configuration options.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Operator {
+    /// Number of operators.
+    pub count: usize,
+    /// Operators x-only public keys.
+    pub xonly_pks: Vec<secp256k1::XOnlyPublicKey>,
+    /// Number of blocks after which operator can take reimburse the bridge fund if they are honest.
+    pub takes_after: u32,
+    /// Operator: number of kickoff UTXOs per funding transaction.
+    pub kickoff_utxos_per_tx: usize,
+    /// All Secret keys. Just for testing purposes.
+    pub all_secret_keys: Option<Vec<secp256k1::SecretKey>>,
+}
+impl Default for Operator {
+    fn default() -> Self {
+        Self {
+            count: 3,
+            xonly_pks: vec![],
+            takes_after: 5,
+            kickoff_utxos_per_tx: 10,
+            all_secret_keys: None,
+        }
+    }
+}
+
+/// Verifier configuration options.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct Verifier {
+    /// Number of verifiers.
+    pub count: usize,
+    /// Verifiers public keys.
+    pub public_keys: Vec<secp256k1::PublicKey>,
+    /// All Secret keys. Just for testing purposes.
+    pub all_secret_keys: Option<Vec<secp256k1::SecretKey>>,
+    /// Verifier endpoints.
+    pub endpoints: Option<Vec<String>>,
+}
+impl Default for Verifier {
+    fn default() -> Self {
+        Self {
+            public_keys: vec![],
+            count: 7,
+            all_secret_keys: None,
+            endpoints: None,
+        }
+    }
+}
+
 /// Configuration options for any Clementine target (tests, binaries etc.).
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct BridgeConfig {
+    /// PostgreSQL database configuration options.
+    pub database: Database,
+    /// Bitcoin connection configuration options.
+    pub bitcoin: Bitcoin,
+    /// Operator configuration options.
+    pub operator: Operator,
+    /// Verifier configuration options.
+    pub verifier: Verifier,
+
     /// Host of the operator or the verifier
     pub host: String,
     /// Port of the operator or the verifier
     pub port: u16,
-    /// Bitcoin network to work on.
-    pub network: Network,
     /// Secret key for the operator or the verifier.
     pub secret_key: secp256k1::SecretKey,
-    /// Verifiers public keys.
-    pub verifiers_public_keys: Vec<secp256k1::PublicKey>,
-    /// Number of verifiers.
-    pub num_verifiers: usize,
-    /// Operators x-only public keys.
-    pub operators_xonly_pks: Vec<secp256k1::XOnlyPublicKey>,
     /// Operators wallet addresses.
     pub operator_wallet_addresses: Vec<bitcoin::Address<NetworkUnchecked>>,
     /// Number of operators.
-    pub num_operators: usize,
-    /// Operator's fee for withdrawal, in satoshis.
     pub operator_withdrawal_fee_sats: Option<u64>,
     /// Number of blocks after which user can take deposit back if deposit request fails.
     pub user_takes_after: u32,
-    /// Number of blocks after which operator can take reimburse the bridge fund if they are honest.
-    pub operator_takes_after: u32,
     /// Bridge amount in satoshis.
     pub bridge_amount_sats: u64,
-    /// Operator: number of kickoff UTXOs per funding transaction.
-    pub operator_num_kickoff_utxos_per_tx: usize,
     /// Threshold for confirmation.
     pub confirmation_threshold: u32,
-    /// Bitcoin remote procedure call URL.
-    pub bitcoin_rpc_url: String,
-    /// Bitcoin RPC user.
-    pub bitcoin_rpc_user: String,
-    /// Bitcoin RPC user password.
-    pub bitcoin_rpc_password: String,
-    /// All Secret keys. Just for testing purposes.
-    pub all_verifiers_secret_keys: Option<Vec<secp256k1::SecretKey>>,
-    /// All Secret keys. Just for testing purposes.
-    pub all_operators_secret_keys: Option<Vec<secp256k1::SecretKey>>,
-    /// Verifier endpoints.
-    pub verifier_endpoints: Option<Vec<String>>,
-    /// PostgreSQL database host address.
-    pub db_host: String,
-    /// PostgreSQL database port.
-    pub db_port: usize,
-    /// PostgreSQL database user name.
-    pub db_user: String,
-    /// PostgreSQL database user password.
-    pub db_password: String,
-    /// PostgreSQL database name.
-    pub db_name: String,
     /// Citrea RPC URL.
     pub citrea_rpc_url: String,
     /// Bridge contract address.
     pub bridge_contract_address: String,
 }
+impl Default for BridgeConfig {
+    fn default() -> Self {
+        Self {
+            database: Database::default(),
+            bitcoin: Bitcoin::default(),
+            operator: Operator::default(),
+            verifier: Verifier::default(),
 
-impl BridgeConfig {
-    /// Create a new `BridgeConfig` with default values.
-    pub fn new() -> Self {
-        BridgeConfig {
-            ..Default::default()
+            host: "127.0.0.1".to_string(),
+            port: 3030,
+            secret_key: secp256k1::SecretKey::new(&mut secp256k1::rand::thread_rng()),
+            user_takes_after: 5,
+            bridge_amount_sats: 100_000_000,
+            confirmation_threshold: 1,
+            operator_withdrawal_fee_sats: None,
+            operator_wallet_addresses: vec![],
+            citrea_rpc_url: "http://127.0.0.1:12345".to_string(),
+            bridge_contract_address: "3100000000000000000000000000000000000002".to_string(),
         }
     }
+}
 
+impl BridgeConfig {
     /// Read contents of a TOML file and generate a `BridgeConfig`.
     pub fn try_parse_file(path: PathBuf) -> Result<Self, BridgeError> {
         let mut contents = String::new();
@@ -113,41 +198,6 @@ impl BridgeConfig {
     }
 }
 
-impl Default for BridgeConfig {
-    fn default() -> Self {
-        Self {
-            host: "127.0.0.1".to_string(),
-            port: 3030,
-            secret_key: secp256k1::SecretKey::new(&mut secp256k1::rand::thread_rng()),
-            verifiers_public_keys: vec![],
-            num_verifiers: 7,
-            operators_xonly_pks: vec![],
-            operator_wallet_addresses: vec![],
-            num_operators: 3,
-            operator_withdrawal_fee_sats: None,
-            user_takes_after: 5,
-            operator_takes_after: 5,
-            bridge_amount_sats: 100_000_000,
-            operator_num_kickoff_utxos_per_tx: 10,
-            confirmation_threshold: 1,
-            network: Network::Regtest,
-            bitcoin_rpc_url: "http://127.0.0.1:18443".to_string(),
-            bitcoin_rpc_user: "admin".to_string(),
-            bitcoin_rpc_password: "admin".to_string(),
-            all_verifiers_secret_keys: None,
-            all_operators_secret_keys: None,
-            verifier_endpoints: None,
-            db_host: "127.0.0.1".to_string(),
-            db_port: 5432,
-            db_user: "postgres".to_string(),
-            db_password: "postgres".to_string(),
-            db_name: "postgres".to_string(),
-            citrea_rpc_url: "http://127.0.0.1:12345".to_string(),
-            bridge_contract_address: "3100000000000000000000000000000000000002".to_string(),
-        }
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::BridgeConfig;
@@ -170,7 +220,7 @@ mod tests {
             Err(e) => println!("{e:#?}"),
         };
 
-        let init = BridgeConfig::new();
+        let init = BridgeConfig::default();
         match BridgeConfig::try_parse_from(toml::to_string(&init).unwrap()) {
             Ok(c) => println!("{c:#?}"),
             Err(e) => panic!("{e:#?}"),
diff --git a/core/src/database/common.rs b/core/src/database/common.rs
index 61e74a91..721a122f 100644
--- a/core/src/database/common.rs
+++ b/core/src/database/common.rs
@@ -26,15 +26,15 @@ impl Database {
     /// TODO: Pass the reference &BridgeConfig instead of copying BridgeConfig.
     pub async fn new(config: BridgeConfig) -> Result<Self, BridgeError> {
         let url = "postgresql://".to_owned()
-            + config.db_host.as_str()
+            + config.database.host.as_str()
             + ":"
-            + config.db_port.to_string().as_str()
+            + config.database.port.to_string().as_str()
             + "?dbname="
-            + config.db_name.as_str()
+            + config.database.name.as_str()
             + "&user="
-            + config.db_user.as_str()
+            + config.database.user.as_str()
             + "&password="
-            + config.db_password.as_str();
+            + config.database.password.as_str();
         tracing::debug!("Connecting database: {}", url);
 
         match sqlx::PgPool::connect(url.as_str()).await {
@@ -54,11 +54,11 @@ impl Database {
         database_name: &str,
     ) -> Result<(), BridgeError> {
         let url = "postgresql://".to_owned()
-            + config.db_user.as_str()
+            + config.database.user.as_str()
             + ":"
-            + config.db_password.as_str()
+            + config.database.password.as_str()
             + "@"
-            + config.db_host.as_str();
+            + config.database.host.as_str();
         let conn = sqlx::PgPool::connect(url.as_str()).await?;
 
         let query = format!("DROP DATABASE IF EXISTS {database_name}");
@@ -81,23 +81,26 @@ impl Database {
         database_name: &str,
     ) -> Result<BridgeConfig, BridgeError> {
         let url = "postgresql://".to_owned()
-            + config.db_user.as_str()
+            + config.database.user.as_str()
             + ":"
-            + config.db_password.as_str()
+            + config.database.password.as_str()
             + "@"
-            + config.db_host.as_str();
+            + config.database.host.as_str();
         let conn = sqlx::PgPool::connect(url.as_str()).await?;
         Database::drop_database(config.clone(), database_name).await?;
         let query = format!(
             "CREATE DATABASE {} WITH OWNER {}",
-            database_name, config.db_user
+            database_name, config.database.user
         );
         sqlx::query(&query).execute(&conn).await?;
 
         conn.close().await;
 
         let config = BridgeConfig {
-            db_name: database_name.to_string(),
+            database: crate::config::Database {
+                name: database_name.to_string(),
+                ..config.database
+            },
             ..config
         };
 
@@ -769,12 +772,12 @@ mod tests {
     #[tokio::test]
     #[should_panic]
     async fn test_invalid_connection() {
-        let mut config = BridgeConfig::new();
-        config.db_host = "nonexistinghost".to_string();
-        config.db_name = "nonexistingpassword".to_string();
-        config.db_user = "nonexistinguser".to_string();
-        config.db_password = "nonexistingpassword".to_string();
-        config.db_port = 123;
+        let mut config = BridgeConfig::default();
+        config.database.host = "nonexistinghost".to_string();
+        config.database.name = "nonexistingpassword".to_string();
+        config.database.user = "nonexistinguser".to_string();
+        config.database.password = "nonexistingpassword".to_string();
+        config.database.port = 123;
 
         Database::new(config).await.unwrap();
     }
@@ -817,7 +820,7 @@ mod tests {
         ])
         .unwrap();
         let outpoint = OutPoint::null();
-        let taproot_address = Address::p2tr(&secp, xonly_public_key, None, config.network);
+        let taproot_address = Address::p2tr(&secp, xonly_public_key, None, config.bitcoin.network);
         let evm_address = EVMAddress([1u8; 20]);
         database
             .save_deposit_info(
diff --git a/core/src/mock/common.rs b/core/src/mock/common.rs
index c07d5784..29a9074b 100644
--- a/core/src/mock/common.rs
+++ b/core/src/mock/common.rs
@@ -34,11 +34,11 @@ pub fn get_test_config(configuration_file: &str) -> Result<BridgeConfig, BridgeE
     // Overwrite user's environment to test's hard coded data if environment
     // file is specified.
     if let Some(env_config) = env_config {
-        config.db_host = env_config.db_host;
-        config.db_port = env_config.db_port;
-        config.db_user = env_config.db_user;
-        config.db_password = env_config.db_password;
-        config.db_name = env_config.db_name;
+        config.database.host = env_config.database.host;
+        config.database.port = env_config.database.port;
+        config.database.user = env_config.database.user;
+        config.database.password = env_config.database.password;
+        config.database.name = env_config.database.name;
     };
 
     #[cfg(test)]
diff --git a/core/src/mock/rpc.rs b/core/src/mock/rpc.rs
index 1e9cfcf5..560e6773 100644
--- a/core/src/mock/rpc.rs
+++ b/core/src/mock/rpc.rs
@@ -23,12 +23,12 @@ macro_rules! create_extended_rpc {
             .unwrap()
             .to_owned();
 
-        $config.bitcoin_rpc_url = handle.to_string();
+        $config.bitcoin.rpc_url = handle.to_string();
 
         ExtendedRpc::<bitcoin_mock_rpc::Client>::new(
-            $config.bitcoin_rpc_url.clone(),
-            $config.bitcoin_rpc_user.clone(),
-            $config.bitcoin_rpc_password.clone(),
+            $config.bitcoin.rpc_url.clone(),
+            $config.bitcoin.rpc_user.clone(),
+            $config.bitcoin.rpc_password.clone(),
         )
     }};
 }
@@ -47,12 +47,12 @@ macro_rules! create_extended_rpc {
         println!("Using Bitcoin regtest for testing...");
 
         // Mutation for consistency with above defined macro
-        $config.bitcoin_rpc_url = $config.bitcoin_rpc_url.clone();
+        $config.bitcoin.rpc_url = $config.bitcoin.rpc_url.clone();
 
         ExtendedRpc::<bitcoincore_rpc::Client>::new(
-            $config.bitcoin_rpc_url.clone(),
-            $config.bitcoin_rpc_user.clone(),
-            $config.bitcoin_rpc_password.clone(),
+            $config.bitcoin.rpc_url.clone(),
+            $config.bitcoin.rpc_user.clone(),
+            $config.bitcoin.rpc_password.clone(),
         )
     }};
 }
diff --git a/core/src/operator.rs b/core/src/operator.rs
index a20ff94d..f4116d7c 100644
--- a/core/src/operator.rs
+++ b/core/src/operator.rs
@@ -44,19 +44,20 @@ where
     /// Creates a new `Operator`.
     #[tracing::instrument(skip_all, err(level = tracing::Level::ERROR))]
     pub async fn new(config: BridgeConfig, rpc: ExtendedRpc<R>) -> Result<Self, BridgeError> {
-        // let num_verifiers = config.verifiers_public_keys.len();
+        // let num_verifiers = config.verifier.public_keys.len();
 
-        let signer = Actor::new(config.secret_key, config.network);
+        let signer = Actor::new(config.secret_key, config.bitcoin.network);
 
         let db = OperatorDB::new(config.clone()).await;
 
         let nofn_xonly_pk = secp256k1::XOnlyPublicKey::from_musig2_pks(
-            config.verifiers_public_keys.clone(),
+            config.verifier.public_keys.clone(),
             None,
             false,
         );
         let idx = config
-            .operators_xonly_pks
+            .operator
+            .xonly_pks
             .iter()
             .position(|xonly_pk| xonly_pk == &signer.xonly_public_key)
             .ok_or(BridgeError::ServerError(std::io::Error::other(format!(
@@ -96,7 +97,7 @@ where
         tracing::debug!(
             "Operator idx: {:?}, db created with name: {:?}",
             idx,
-            config.db_name
+            config.database.name
         );
 
         Ok(Self {
@@ -141,7 +142,7 @@ where
             &evm_address,
             self.config.bridge_amount_sats,
             self.config.confirmation_threshold,
-            self.config.network,
+            self.config.bitcoin.network,
             self.config.user_takes_after,
         )?;
 
@@ -220,12 +221,12 @@ where
             // and (num_kickoff_utxos + 2) outputs where the first k outputs are
             // the kickoff outputs, the penultimante output is the change output,
             // and the last output is the anyonecanpay output for fee bumping.
-            let kickoff_tx_min_relay_fee = match self.config.operator_num_kickoff_utxos_per_tx {
-                0..=250 => 154 + 43 * self.config.operator_num_kickoff_utxos_per_tx, // Handles all values from 0 to 250
-                _ => 156 + 43 * self.config.operator_num_kickoff_utxos_per_tx, // Handles all other values
+            let kickoff_tx_min_relay_fee = match self.config.operator.kickoff_utxos_per_tx {
+                0..=250 => 154 + 43 * self.config.operator.kickoff_utxos_per_tx, // Handles all values from 0 to 250
+                _ => 156 + 43 * self.config.operator.kickoff_utxos_per_tx, // Handles all other values
             };
             if funding_utxo.txout.value.to_sat()
-                < (KICKOFF_UTXO_AMOUNT_SATS * self.config.operator_num_kickoff_utxos_per_tx as u64
+                < (KICKOFF_UTXO_AMOUNT_SATS * self.config.operator.kickoff_utxos_per_tx as u64
                     + kickoff_tx_min_relay_fee as u64
                     + 330)
             {
@@ -237,8 +238,8 @@ where
                 &funding_utxo,
                 &self.nofn_xonly_pk,
                 &self.signer.xonly_public_key,
-                self.config.network,
-                self.config.operator_num_kickoff_utxos_per_tx,
+                self.config.bitcoin.network,
+                self.config.operator.kickoff_utxos_per_tx,
             );
             tracing::debug!(
                 "Funding UTXO found: {:?} kickoff UTXO is created for deposit UTXO: {:?}",
@@ -266,9 +267,9 @@ where
             let change_utxo = UTXO {
                 outpoint: OutPoint {
                     txid: kickoff_tx_handler.tx.compute_txid(),
-                    vout: self.config.operator_num_kickoff_utxos_per_tx as u32,
+                    vout: self.config.operator.kickoff_utxos_per_tx as u32,
                 },
-                txout: kickoff_tx_handler.tx.output[self.config.operator_num_kickoff_utxos_per_tx]
+                txout: kickoff_tx_handler.tx.output[self.config.operator.kickoff_utxos_per_tx]
                     .clone(),
             };
             tracing::debug!(
@@ -305,7 +306,7 @@ where
                     Some(&mut tx),
                     kickoff_tx_handler.tx.compute_txid(),
                     kickoff_tx_handler.tx.raw_hex(),
-                    self.config.operator_num_kickoff_utxos_per_tx,
+                    self.config.operator.kickoff_utxos_per_tx,
                     funding_utxo.outpoint.txid,
                 )
                 .await?;
@@ -484,11 +485,11 @@ where
                     &utils::SECP,
                     *utils::UNSPENDABLE_XONLY_PUBKEY,
                     None,
-                    self.config.network,
+                    self.config.bitcoin.network,
                 )
                 .as_unchecked(),
                 &self.nofn_xonly_pk,
-                self.config.network,
+                self.config.bitcoin.network,
                 self.config.user_takes_after,
                 self.config.bridge_amount_sats,
             );
@@ -560,9 +561,9 @@ where
             &self.signer.xonly_public_key,
             self.idx,
             &self.nofn_xonly_pk,
-            self.config.network,
+            self.config.bitcoin.network,
             self.config.user_takes_after,
-            self.config.operator_takes_after,
+            self.config.operator.takes_after,
             self.config.bridge_amount_sats,
         );
 
@@ -611,11 +612,11 @@ where
                 &utils::SECP,
                 *utils::UNSPENDABLE_XONLY_PUBKEY,
                 None,
-                self.config.network,
+                self.config.bitcoin.network,
             )
             .as_unchecked(),
             &self.nofn_xonly_pk,
-            self.config.network,
+            self.config.bitcoin.network,
             self.config.user_takes_after,
             self.config.bridge_amount_sats,
         );
@@ -629,8 +630,8 @@ where
             slash_or_take_utxo,
             &self.signer.xonly_public_key,
             &self.nofn_xonly_pk,
-            self.config.network,
-            self.config.operator_takes_after,
+            self.config.bitcoin.network,
+            self.config.operator.takes_after,
             self.config.bridge_amount_sats,
             self.config.operator_wallet_addresses[self.idx].clone(),
         );
diff --git a/core/src/servers.rs b/core/src/servers.rs
index e13e9313..47306192 100644
--- a/core/src/servers.rs
+++ b/core/src/servers.rs
@@ -137,7 +137,7 @@ pub async fn create_verifiers_and_operators(
     let mut config = create_test_config_with_thread_name(config_name, None).await;
     let start_port = config.port;
     let rpc = create_extended_rpc!(config);
-    let all_verifiers_secret_keys = config.all_verifiers_secret_keys.clone().unwrap_or_else(|| {
+    let all_verifiers_secret_keys = config.verifier.all_secret_keys.clone().unwrap_or_else(|| {
         panic!("All secret keys of the verifiers are required for testing");
     });
     let verifier_futures = all_verifiers_secret_keys
@@ -182,7 +182,7 @@ pub async fn create_verifiers_and_operators(
         .map(|(_, c)| c.clone())
         .collect::<Vec<_>>();
 
-    let all_operators_secret_keys = config.all_operators_secret_keys.clone().unwrap_or_else(|| {
+    let all_operators_secret_keys = config.operator.all_secret_keys.clone().unwrap_or_else(|| {
         panic!("All secret keys of the operators are required for testing");
     });
 
diff --git a/core/src/transaction_builder.rs b/core/src/transaction_builder.rs
index 3a96b8a5..8345e2ae 100644
--- a/core/src/transaction_builder.rs
+++ b/core/src/transaction_builder.rs
@@ -208,21 +208,21 @@ impl TransactionBuilder {
         nofn_xonly_pk: &XOnlyPublicKey,
         operator_xonly_pk: &XOnlyPublicKey,
         network: bitcoin::Network,
-        num_kickoff_utxos_per_tx: usize,
+        kickoff_utxos_per_tx: usize,
     ) -> TxHandler {
         // Here, we are calculating the minimum relay fee for the kickoff tx based on the number of kickoff utxos per tx.
-        // The formula is: 154 + 43 * num_kickoff_utxos_per_tx where
+        // The formula is: 154 + 43 * kickoff_utxos_per_tx where
         // 154 = (Signature as witness, 66 bytes + 2 bytes from flags) / 4
         // + 43 * 2 from change and anyone can spend txouts
         // + 41 from the single input (32 + 8 + 1)
         // 4 + 4 + 1 + 1 from locktime, version, and VarInt bases of
         // the number of inputs and outputs.
-        let kickoff_tx_min_relay_fee = match num_kickoff_utxos_per_tx {
-            0..=250 => 154 + 43 * num_kickoff_utxos_per_tx, // Handles all values from 0 to 250
-            _ => 156 + 43 * num_kickoff_utxos_per_tx,       // Handles all other values
+        let kickoff_tx_min_relay_fee = match kickoff_utxos_per_tx {
+            0..=250 => 154 + 43 * kickoff_utxos_per_tx, // Handles all values from 0 to 250
+            _ => 156 + 43 * kickoff_utxos_per_tx,       // Handles all other values
         };
 
-        //  = 154 + 43 * num_kickoff_utxos_per_tx;
+        //  = 154 + 43 * kickoff_utxos_per_tx;
         let tx_ins = TransactionBuilder::create_tx_ins(vec![funding_utxo.outpoint]);
         let musig2_and_operator_script = script_builder::create_musig2_and_operator_multisig_script(
             nofn_xonly_pk,
@@ -235,7 +235,7 @@ impl TransactionBuilder {
         );
         let operator_address = Address::p2tr(&utils::SECP, *operator_xonly_pk, None, network);
         let change_amount = funding_utxo.txout.value
-            - Amount::from_sat(KICKOFF_UTXO_AMOUNT_SATS * num_kickoff_utxos_per_tx as u64)
+            - Amount::from_sat(KICKOFF_UTXO_AMOUNT_SATS * kickoff_utxos_per_tx as u64)
             - script_builder::anyone_can_spend_txout().value
             - Amount::from_sat(kickoff_tx_min_relay_fee as u64);
         tracing::debug!("Change amount: {:?}", change_amount);
@@ -244,7 +244,7 @@ impl TransactionBuilder {
                 Amount::from_sat(KICKOFF_UTXO_AMOUNT_SATS),
                 musig2_and_operator_address.script_pubkey(),
             );
-            num_kickoff_utxos_per_tx
+            kickoff_utxos_per_tx
         ];
 
         tx_outs_raw.push((change_amount, operator_address.script_pubkey()));
diff --git a/core/src/user.rs b/core/src/user.rs
index 2c40359e..4bb3b331 100644
--- a/core/src/user.rs
+++ b/core/src/user.rs
@@ -28,10 +28,10 @@ where
 {
     /// Creates a new `User`.
     pub fn new(rpc: ExtendedRpc<R>, sk: SecretKey, config: BridgeConfig) -> Self {
-        let signer = Actor::new(sk, config.network);
+        let signer = Actor::new(sk, config.bitcoin.network);
 
         let nofn_xonly_pk = secp256k1::XOnlyPublicKey::from_musig2_pks(
-            config.verifiers_public_keys.clone(),
+            config.verifier.public_keys.clone(),
             None,
             false,
         );
@@ -54,7 +54,7 @@ where
             self.signer.address.as_unchecked(),
             &evm_address,
             self.config.bridge_amount_sats,
-            self.config.network,
+            self.config.bitcoin.network,
             self.config.user_takes_after,
         );
 
@@ -72,7 +72,7 @@ where
             self.signer.address.as_unchecked(),
             &evm_address,
             self.config.bridge_amount_sats,
-            self.config.network,
+            self.config.bitcoin.network,
             self.config.user_takes_after,
         );
 
diff --git a/core/src/verifier.rs b/core/src/verifier.rs
index 3fbae82b..9dc728c0 100644
--- a/core/src/verifier.rs
+++ b/core/src/verifier.rs
@@ -37,24 +37,24 @@ where
     R: RpcApiWrapper,
 {
     pub async fn new(rpc: ExtendedRpc<R>, config: BridgeConfig) -> Result<Self, BridgeError> {
-        let signer = Actor::new(config.secret_key, config.network);
+        let signer = Actor::new(config.secret_key, config.bitcoin.network);
 
         let pk: secp256k1::PublicKey = config.secret_key.public_key(&utils::SECP);
 
         // Generated public key must be in given public key list.
-        if !config.verifiers_public_keys.contains(&pk) {
+        if !config.verifier.public_keys.contains(&pk) {
             return Err(BridgeError::PublicKeyNotFound);
         }
 
         let db = VerifierDB::new(config.clone()).await;
 
         let nofn_xonly_pk = secp256k1::XOnlyPublicKey::from_musig2_pks(
-            config.verifiers_public_keys.clone(),
+            config.verifier.public_keys.clone(),
             None,
             false,
         );
 
-        let operator_xonly_pks = config.operators_xonly_pks.clone();
+        let operator_xonly_pks = config.operator.xonly_pks.clone();
 
         Ok(Verifier {
             rpc,
@@ -86,7 +86,7 @@ where
             &evm_address,
             self.config.bridge_amount_sats,
             self.config.confirmation_threshold,
-            self.config.network,
+            self.config.bitcoin.network,
             self.config.user_takes_after,
         )?;
 
@@ -183,7 +183,7 @@ where
             utils::SECP.verify_schnorr(
                 &operators_kickoff_sigs[i],
                 &secp256k1::Message::from_digest(kickoff_sig_hash),
-                &self.config.operators_xonly_pks[i],
+                &self.config.operator.xonly_pks[i],
             )?;
 
             // Check if for each operator the address of the kickoff_utxo is correct TODO: Maybe handle the possible errors better
@@ -191,7 +191,7 @@ where
                 TransactionBuilder::create_kickoff_address(
                     &self.nofn_xonly_pk,
                     &self.operator_xonly_pks[i],
-                    self.config.network,
+                    self.config.bitcoin.network,
                 );
             tracing::debug!(
                 "musig2_and_operator_address.script_pubkey: {:?}",
@@ -206,12 +206,12 @@ where
             let mut slash_or_take_tx_handler = TransactionBuilder::create_slash_or_take_tx(
                 deposit_outpoint,
                 kickoff_utxo.clone(),
-                &self.config.operators_xonly_pks[i],
+                &self.config.operator.xonly_pks[i],
                 i,
                 &self.nofn_xonly_pk,
-                self.config.network,
+                self.config.bitcoin.network,
                 self.config.user_takes_after,
-                self.config.operator_takes_after,
+                self.config.operator.takes_after,
                 self.config.bridge_amount_sats,
             );
             let slash_or_take_tx_sighash =
@@ -240,7 +240,7 @@ where
             .save_sighashes_and_get_nonces(
                 Some(&mut dbtx),
                 deposit_outpoint,
-                self.config.num_operators + 1,
+                self.config.operator.count + 1,
                 &slash_or_take_sighashes,
             )
             .await?
@@ -255,7 +255,7 @@ where
             .zip(nonces.iter())
             .map(|(sighash, (sec_nonce, agg_nonce))| {
                 musig2::partial_sign(
-                    self.config.verifiers_public_keys.clone(),
+                    self.config.verifier.public_keys.clone(),
                     None,
                     false,
                     *sec_nonce,
@@ -299,7 +299,7 @@ where
             &evm_address,
             &recovery_taproot_address,
             &self.nofn_xonly_pk,
-            self.config.network,
+            self.config.bitcoin.network,
             self.config.user_takes_after,
             self.config.bridge_amount_sats,
         );
@@ -335,9 +335,9 @@ where
                     &self.operator_xonly_pks[index],
                     index,
                     &self.nofn_xonly_pk,
-                    self.config.network,
+                    self.config.bitcoin.network,
                     self.config.user_takes_after,
-                    self.config.operator_takes_after,
+                    self.config.operator.takes_after,
                     self.config.bridge_amount_sats,
                 );
                 let slash_or_take_sighash =
@@ -365,8 +365,8 @@ where
                     slash_or_take_utxo,
                     &self.operator_xonly_pks[index],
                     &self.nofn_xonly_pk,
-                    self.config.network,
-                    self.config.operator_takes_after,
+                    self.config.bitcoin.network,
+                    self.config.operator.takes_after,
                     self.config.bridge_amount_sats,
                     self.config.operator_wallet_addresses[index].clone(),
                 );
@@ -395,7 +395,7 @@ where
             .zip(nonces.iter())
             .map(|(sighash, (sec_nonce, agg_nonce))| {
                 musig2::partial_sign(
-                    self.config.verifiers_public_keys.clone(),
+                    self.config.verifier.public_keys.clone(),
                     None,
                     true,
                     *sec_nonce,
@@ -431,9 +431,9 @@ where
                     &self.operator_xonly_pks[index],
                     index,
                     &self.nofn_xonly_pk,
-                    self.config.network,
+                    self.config.bitcoin.network,
                     self.config.user_takes_after,
-                    self.config.operator_takes_after,
+                    self.config.operator.takes_after,
                     self.config.bridge_amount_sats,
                 );
                 let slash_or_take_utxo = UTXO {
@@ -448,8 +448,8 @@ where
                     slash_or_take_utxo,
                     &self.operator_xonly_pks[index],
                     &self.nofn_xonly_pk,
-                    self.config.network,
-                    self.config.operator_takes_after,
+                    self.config.bitcoin.network,
+                    self.config.operator.takes_after,
                     self.config.bridge_amount_sats,
                     self.config.operator_wallet_addresses[index].clone(),
                 );
@@ -501,7 +501,7 @@ where
             .ok_or(BridgeError::NoncesNotFound)?;
 
         let move_tx_sig = musig2::partial_sign(
-            self.config.verifiers_public_keys.clone(),
+            self.config.verifier.public_keys.clone(),
             None,
             false,
             nonces[0].0,
@@ -511,7 +511,7 @@ where
         );
 
         // let move_reveal_sig = musig2::partial_sign(
-        //     self.config.verifiers_public_keys.clone(),
+        //     self.config.verifier.public_keys.clone(),
         //     None,
         //     nonces[1].0,
         //     nonces[2].1.clone(),
diff --git a/core/tests/common.rs b/core/tests/common.rs
index 9bc32acf..8acd082d 100644
--- a/core/tests/common.rs
+++ b/core/tests/common.rs
@@ -33,7 +33,7 @@ pub async fn run_multiple_deposits(test_config_name: &str) {
 
     let secret_key = secp256k1::SecretKey::new(&mut secp256k1::rand::thread_rng());
 
-    let signer_address = Actor::new(secret_key, config.network)
+    let signer_address = Actor::new(secret_key, config.bitcoin.network)
         .address
         .as_unchecked()
         .clone();
@@ -42,7 +42,7 @@ pub async fn run_multiple_deposits(test_config_name: &str) {
     let evm_address = EVMAddress([1u8; 20]);
     let deposit_address = user.get_deposit_address(evm_address).unwrap();
     let mut deposit_outpoints = Vec::new();
-    for _ in 0..config.operator_num_kickoff_utxos_per_tx + 1 {
+    for _ in 0..config.operator.kickoff_utxos_per_tx + 1 {
         let deposit_outpoint = rpc
             .send_to_address(&deposit_address, config.bridge_amount_sats)
             .unwrap();
@@ -100,7 +100,7 @@ pub async fn run_multiple_deposits(test_config_name: &str) {
             .aggregate_slash_or_take_sigs_rpc(
                 deposit_outpoint,
                 kickoff_utxos.clone(),
-                agg_nonces[config.num_operators + 1..2 * config.num_operators + 1].to_vec(),
+                agg_nonces[config.operator.count + 1..2 * config.operator.count + 1].to_vec(),
                 slash_or_take_partial_sigs,
             )
             .await
@@ -119,7 +119,7 @@ pub async fn run_multiple_deposits(test_config_name: &str) {
             .aggregate_operator_take_sigs_rpc(
                 deposit_outpoint,
                 kickoff_utxos.clone(),
-                agg_nonces[1..config.num_operators + 1].to_vec(),
+                agg_nonces[1..config.operator.count + 1].to_vec(),
                 operator_take_partial_sigs,
             )
             .await
@@ -156,7 +156,7 @@ pub async fn run_multiple_deposits(test_config_name: &str) {
         &secp,
         secret_key.x_only_public_key(&secp).0,
         None,
-        config.network,
+        config.bitcoin.network,
     );
     let (user_utxo, user_txout, user_sig) = user
         .generate_withdrawal_sig(
@@ -185,7 +185,7 @@ pub async fn run_multiple_deposits(test_config_name: &str) {
     let withdrawal_provide_txid = operators[1]
         .0
         .new_withdrawal_sig_rpc(
-            config.operator_num_kickoff_utxos_per_tx as u32 - 1,
+            config.operator.kickoff_utxos_per_tx as u32 - 1,
             user_sig,
             user_utxo,
             user_txout,
@@ -196,8 +196,8 @@ pub async fn run_multiple_deposits(test_config_name: &str) {
     let txs_to_be_sent_penultimate = operators[1]
         .0
         .withdrawal_proved_on_citrea_rpc(
-            config.operator_num_kickoff_utxos_per_tx as u32 - 1,
-            deposit_outpoints[config.operator_num_kickoff_utxos_per_tx - 1],
+            config.operator.kickoff_utxos_per_tx as u32 - 1,
+            deposit_outpoints[config.operator.kickoff_utxos_per_tx - 1],
         )
         .await
         .unwrap();
@@ -217,8 +217,8 @@ pub async fn run_multiple_deposits(test_config_name: &str) {
     let txs_to_be_sent_last = operators[2]
         .0
         .withdrawal_proved_on_citrea_rpc(
-            config.operator_num_kickoff_utxos_per_tx as u32,
-            deposit_outpoints[config.operator_num_kickoff_utxos_per_tx],
+            config.operator.kickoff_utxos_per_tx as u32,
+            deposit_outpoints[config.operator.kickoff_utxos_per_tx],
         )
         .await
         .unwrap();
@@ -247,7 +247,7 @@ pub async fn run_single_deposit(
 
     let secret_key = secp256k1::SecretKey::new(&mut secp256k1::rand::thread_rng());
 
-    let signer_address = Actor::new(secret_key, config.network)
+    let signer_address = Actor::new(secret_key, config.bitcoin.network)
         .address
         .as_unchecked()
         .clone();
@@ -318,7 +318,7 @@ pub async fn run_single_deposit(
         .aggregate_slash_or_take_sigs_rpc(
             deposit_outpoint,
             kickoff_utxos.clone(),
-            agg_nonces[config.num_operators + 1..2 * config.num_operators + 1].to_vec(),
+            agg_nonces[config.operator.count + 1..2 * config.operator.count + 1].to_vec(),
             slash_or_take_partial_sigs,
         )
         .await
@@ -343,7 +343,7 @@ pub async fn run_single_deposit(
         .aggregate_operator_take_sigs_rpc(
             deposit_outpoint,
             kickoff_utxos.clone(),
-            agg_nonces[1..config.num_operators + 1].to_vec(),
+            agg_nonces[1..config.operator.count + 1].to_vec(),
             operator_take_partial_sigs,
         )
         .await
@@ -412,7 +412,7 @@ mod tests {
 
         let secret_key = secp256k1::SecretKey::new(&mut secp256k1::rand::thread_rng());
 
-        let signer_address = Actor::new(secret_key, config.network)
+        let signer_address = Actor::new(secret_key, config.bitcoin.network)
             .address
             .as_unchecked()
             .clone();
@@ -525,7 +525,7 @@ mod tests {
             .aggregate_slash_or_take_sigs_rpc(
                 deposit_outpoint,
                 kickoff_utxos.clone(),
-                agg_nonces[config.num_operators + 1..2 * config.num_operators + 1].to_vec(),
+                agg_nonces[config.operator.count + 1..2 * config.operator.count + 1].to_vec(),
                 slash_or_take_partial_sigs,
             )
             .await
@@ -556,7 +556,7 @@ mod tests {
             .aggregate_slash_or_take_sigs_rpc(
                 deposit_outpoint,
                 kickoff_utxos.clone(),
-                agg_nonces[config.num_operators + 1..2 * config.num_operators + 1].to_vec(),
+                agg_nonces[config.operator.count + 1..2 * config.operator.count + 1].to_vec(),
                 slash_or_take_partial_sigs_retry,
             )
             .await
@@ -580,7 +580,7 @@ mod tests {
             .aggregate_operator_take_sigs_rpc(
                 deposit_outpoint,
                 kickoff_utxos.clone(),
-                agg_nonces[1..config.num_operators + 1].to_vec(),
+                agg_nonces[1..config.operator.count + 1].to_vec(),
                 operator_take_partial_sigs,
             )
             .await
@@ -603,7 +603,7 @@ mod tests {
             .aggregate_operator_take_sigs_rpc(
                 deposit_outpoint,
                 kickoff_utxos.clone(),
-                agg_nonces[1..config.num_operators + 1].to_vec(),
+                agg_nonces[1..config.operator.count + 1].to_vec(),
                 operator_take_partial_sigs_retry,
             )
             .await
diff --git a/core/tests/data/test_config.toml b/core/tests/data/test_config.toml
index d6c44376..db4e9278 100644
--- a/core/tests/data/test_config.toml
+++ b/core/tests/data/test_config.toml
@@ -4,31 +4,11 @@ port = 17000
 
 # Secret key of the current actor (operator or verifier)
 secret_key = "3333333333333333333333333333333333333333333333333333333333333333"
-
-# All of the verifiers public keys
-num_verifiers = 7
-verifiers_public_keys = [
-    "034f355bdcb7cc0af728ef3cceb9615d90684bb5b2ca5f859ab0f0b704075871aa",
-    "02466d7fcae563e5cb09a0d1870bb580344804617879a14949cf22285f1bae3f27",
-    "023c72addb4fdf09af94f0c94d7fe92a386a7e70cf8a1d85916386bb2535c7b1b1",
-    "032c0b7cf95324a07d05398b240174dc0c2be444d96b159aa6c7f7b1e668680991",
-    "029ac20335eb38768d2052be1dbbc3c8f6178407458e51e6b4ad22f1d91758895b",
-    "035ab4689e400a4a160cf01cd44730845a54768df8547dcdf073d964f109f18c30",
-    "037962d45b38e8bcf82fa8efa8432a01f20c9a53e24c7d3f11df197cb8e70926da",
-]
-
-# All of the operators x-only public keys.
-num_operators = 3
-operators_xonly_pks = [
-    "4f355bdcb7cc0af728ef3cceb9615d90684bb5b2ca5f859ab0f0b704075871aa",
-    "466d7fcae563e5cb09a0d1870bb580344804617879a14949cf22285f1bae3f27",
-    "3c72addb4fdf09af94f0c94d7fe92a386a7e70cf8a1d85916386bb2535c7b1b1",
-]
-
-# Operator can take funds back after this amount of blocks.
-operator_takes_after = 5
-
-# Operator reimbursement addresses after the 2 week period.
+bridge_amount_sats = 100000000
+user_takes_after = 200
+confirmation_threshold = 1
+citrea_rpc_url = ""
+bridge_contract_address = "3100000000000000000000000000000000000002"
 operator_wallet_addresses = [
     "bcrt1pvaua4gvvglk27al5trh337xz8l8zzhgzageky0xt0dgv64xee8tqwwvzmf",
     "bcrt1pvaua4gvvglk27al5trh337xz8l8zzhgzageky0xt0dgv64xee8tqwwvzmf",
@@ -36,33 +16,46 @@ operator_wallet_addresses = [
 ]
 operator_withdrawal_fee_sats = 100000
 
-operator_num_kickoff_utxos_per_tx = 10
-
-# User can take funds back after this amount of blocks, if deposit fails.
-user_takes_after = 200
+[database]
+host = "127.0.0.1"
+port = 5432
+user = "clementine"
+password = "clementine"
+name = "clementine"
 
-# Bitcoin node configuration options
+[bitcoin]
 network = "regtest"
-bitcoin_rpc_url = "http://127.0.0.1:18443"
-bitcoin_rpc_user = "admin"
-bitcoin_rpc_password = "admin"
-
-# PostgreSQL database credentials.
-db_host = "127.0.0.1"
-db_port = 5432
-db_user = "clementine"
-db_password = "clementine"
-db_name = "clementine"
+rpc_url = "http://127.0.0.1:18443"
+rpc_user = "admin"
+rpc_password = "admin"
 
-bridge_amount_sats = 100000000
-
-confirmation_threshold = 1
-
-citrea_rpc_url = ""
-bridge_contract_address = "3100000000000000000000000000000000000002"
+[operator]
+count = 3
+xonly_pks = [
+    "4f355bdcb7cc0af728ef3cceb9615d90684bb5b2ca5f859ab0f0b704075871aa",
+    "466d7fcae563e5cb09a0d1870bb580344804617879a14949cf22285f1bae3f27",
+    "3c72addb4fdf09af94f0c94d7fe92a386a7e70cf8a1d85916386bb2535c7b1b1",
+]
+takes_after = 5
+kickoff_utxos_per_tx = 10
+all_secret_keys = [
+    "1111111111111111111111111111111111111111111111111111111111111111",
+    "2222222222222222222222222222222222222222222222222222222222222222",
+    "3333333333333333333333333333333333333333333333333333333333333333",
+]
 
-# Testing only fields.
-all_verifiers_secret_keys = [
+[verifier]
+count = 7
+public_keys = [
+    "034f355bdcb7cc0af728ef3cceb9615d90684bb5b2ca5f859ab0f0b704075871aa",
+    "02466d7fcae563e5cb09a0d1870bb580344804617879a14949cf22285f1bae3f27",
+    "023c72addb4fdf09af94f0c94d7fe92a386a7e70cf8a1d85916386bb2535c7b1b1",
+    "032c0b7cf95324a07d05398b240174dc0c2be444d96b159aa6c7f7b1e668680991",
+    "029ac20335eb38768d2052be1dbbc3c8f6178407458e51e6b4ad22f1d91758895b",
+    "035ab4689e400a4a160cf01cd44730845a54768df8547dcdf073d964f109f18c30",
+    "037962d45b38e8bcf82fa8efa8432a01f20c9a53e24c7d3f11df197cb8e70926da",
+]
+all_secret_keys = [
     "1111111111111111111111111111111111111111111111111111111111111111",
     "2222222222222222222222222222222222222222222222222222222222222222",
     "3333333333333333333333333333333333333333333333333333333333333333",
@@ -71,8 +64,3 @@ all_verifiers_secret_keys = [
     "6666666666666666666666666666666666666666666666666666666666666666",
     "7777777777777777777777777777777777777777777777777777777777777777",
 ]
-all_operators_secret_keys = [
-    "1111111111111111111111111111111111111111111111111111111111111111",
-    "2222222222222222222222222222222222222222222222222222222222222222",
-    "3333333333333333333333333333333333333333333333333333333333333333",
-]
diff --git a/core/tests/flow.rs b/core/tests/flow.rs
index db3e3064..7c70069d 100644
--- a/core/tests/flow.rs
+++ b/core/tests/flow.rs
@@ -42,7 +42,7 @@ async fn test_honest_operator_takes_refund() {
         &secp,
         user_sk.x_only_public_key(&secp).0,
         None,
-        config.network,
+        config.bitcoin.network,
     );
     // We are giving 99_800_000 sats to the user so that the operator can pay the withdrawal and profit.
     let (empty_utxo, withdrawal_tx_out, user_sig) = user
@@ -69,7 +69,7 @@ async fn test_honest_operator_takes_refund() {
         rpc.mine_blocks(1).unwrap();
         tracing::debug!("outpoint: {:#?}", outpoint);
     }
-    rpc.mine_blocks(1 + config.operator_takes_after as u64)
+    rpc.mine_blocks(1 + config.operator.takes_after as u64)
         .unwrap();
     // send the last tx
     let operator_take_txid = rpc
@@ -106,7 +106,7 @@ async fn test_withdrawal_fee_too_low() {
         &secp,
         user_sk.x_only_public_key(&secp).0,
         None,
-        config.network,
+        config.bitcoin.network,
     );
     // We are giving 100_000_000 sats to the user so that the operator cannot pay it because it is not profitable.
     let (empty_utxo, withdrawal_tx_out, user_sig) = user
diff --git a/core/tests/musig2.rs b/core/tests/musig2.rs
index f8973661..c82256ef 100644
--- a/core/tests/musig2.rs
+++ b/core/tests/musig2.rs
@@ -25,7 +25,7 @@ async fn test_musig2_key_spend() {
     let mut config: BridgeConfig =
         create_test_config_with_thread_name("test_config.toml", None).await;
     let rpc: ExtendedRpc<_> = create_extended_rpc!(config);
-    let sks = config.all_verifiers_secret_keys.unwrap();
+    let sks = config.verifier.all_secret_keys.unwrap();
     let kp_vec: Vec<Keypair> = sks
         .iter()
         .map(|sk| Keypair::from_secret_key(&secp, sk))
@@ -50,11 +50,12 @@ async fn test_musig2_key_spend() {
     let untweaked_xonly_pubkey: secp256k1::XOnlyPublicKey =
         secp256k1::XOnlyPublicKey::from_slice(&untweaked_pubkey.x_only_public_key().0.serialize())
             .unwrap();
-    let (to_address, _) = TransactionBuilder::create_taproot_address(&[], None, config.network);
+    let (to_address, _) =
+        TransactionBuilder::create_taproot_address(&[], None, config.bitcoin.network);
     let (from_address, from_address_spend_info) = TransactionBuilder::create_taproot_address(
         &[],
         Some(untweaked_xonly_pubkey),
-        config.network,
+        config.bitcoin.network,
     );
     let utxo = rpc.send_to_address(&from_address, 100_000_000).unwrap();
     let prevout = rpc.get_txout_from_outpoint(&utxo).unwrap();
@@ -129,7 +130,7 @@ async fn test_musig2_key_spend_with_script() {
     let mut config: BridgeConfig =
         create_test_config_with_thread_name("test_config.toml", None).await;
     let rpc: ExtendedRpc<_> = create_extended_rpc!(config);
-    let sks = config.all_verifiers_secret_keys.unwrap();
+    let sks = config.verifier.all_secret_keys.unwrap();
     let kp_vec: Vec<Keypair> = sks
         .iter()
         .map(|sk| Keypair::from_secret_key(&secp, sk))
@@ -156,11 +157,12 @@ async fn test_musig2_key_spend_with_script() {
             .unwrap();
     let dummy_script = script::Builder::new().push_int(1).into_script();
     let scripts: Vec<ScriptBuf> = vec![dummy_script];
-    let (to_address, _) = TransactionBuilder::create_taproot_address(&[], None, config.network);
+    let (to_address, _) =
+        TransactionBuilder::create_taproot_address(&[], None, config.bitcoin.network);
     let (from_address, from_address_spend_info) = TransactionBuilder::create_taproot_address(
         &scripts,
         Some(untweaked_xonly_pubkey),
-        config.network,
+        config.bitcoin.network,
     );
     let utxo = rpc.send_to_address(&from_address, 100_000_000).unwrap();
     let prevout = rpc.get_txout_from_outpoint(&utxo).unwrap();
@@ -234,7 +236,7 @@ async fn test_musig2_script_spend() {
     let mut config: BridgeConfig =
         create_test_config_with_thread_name("test_config.toml", None).await;
     let rpc: ExtendedRpc<_> = create_extended_rpc!(config);
-    let sks = config.all_verifiers_secret_keys.unwrap();
+    let sks = config.verifier.all_secret_keys.unwrap();
     let kp_vec: Vec<Keypair> = sks
         .iter()
         .map(|sk| Keypair::from_secret_key(&secp, sk))
diff --git a/core/tests/taproot.rs b/core/tests/taproot.rs
index cb064d15..e3f42dc5 100644
--- a/core/tests/taproot.rs
+++ b/core/tests/taproot.rs
@@ -21,7 +21,7 @@ async fn run() {
     let (xonly_pk, _) = config.secret_key.public_key(&secp).x_only_public_key();
     println!("x only pub key: {:?}", xonly_pk);
 
-    let address = Address::p2tr(&secp, xonly_pk, None, config.network);
+    let address = Address::p2tr(&secp, xonly_pk, None, config.bitcoin.network);
     println!("address: {:?}", address.to_string());
 
     let script = address.script_pubkey();
@@ -48,8 +48,11 @@ async fn run() {
         .push_opcode(OP_CHECKSIG)
         .into_script();
 
-    let (taproot_address, taproot_spend_info) =
-        TransactionBuilder::create_taproot_address(&[to_pay_script.clone()], None, config.network);
+    let (taproot_address, taproot_spend_info) = TransactionBuilder::create_taproot_address(
+        &[to_pay_script.clone()],
+        None,
+        config.bitcoin.network,
+    );
     let utxo = rpc.send_to_address(&taproot_address, 1000).unwrap();
 
     let ins = TransactionBuilder::create_tx_ins(vec![utxo]);
@@ -66,7 +69,7 @@ async fn run() {
 
     let tx = TransactionBuilder::create_btc_tx(ins, tx_outs.clone());
 
-    let signer = Actor::new(config.secret_key, config.network);
+    let signer = Actor::new(config.secret_key, config.bitcoin.network);
 
     let mut tx_details = TxHandler {
         tx: tx.clone(),
@@ -103,7 +106,7 @@ async fn run() {
 
     println!("UTXO: {:?}", utxo);
 
-    // let tx_builder = TransactionBuilder::new(config.verifiers_public_keys.clone(), config);
+    // let tx_builder = TransactionBuilder::new(config.verifier.public_keys.clone(), config);
     // let evm_address: EVMAddress = EVMAddress([1u8; 20]);
     // let deposit_address = tx_builder
     //     .generate_deposit_address(&xonly_pk, &evm_address, BRIDGE_AMOUNT_SATS)
@@ -129,9 +132,9 @@ async fn taproot_key_path_spend() {
     let rpc = create_extended_rpc!(config);
 
     let (xonly_pk, _) = config.secret_key.public_key(&secp).x_only_public_key();
-    let actor = Actor::new(config.secret_key, config.network);
+    let actor = Actor::new(config.secret_key, config.bitcoin.network);
 
-    let address = Address::p2tr(&secp, xonly_pk, None, config.network);
+    let address = Address::p2tr(&secp, xonly_pk, None, config.bitcoin.network);
     const INPUT_AMOUNT: u64 = 600;
     const INPUT_COUNT: u32 = 2;
     let mut inputs = vec![];
@@ -183,7 +186,7 @@ async fn taproot_key_path_spend_2() {
     let mut config = create_test_config_with_thread_name("test_config.toml", None).await;
     let rpc = create_extended_rpc!(config);
 
-    let actor = Actor::new(config.secret_key, config.network);
+    let actor = Actor::new(config.secret_key, config.bitcoin.network);
 
     let address = actor.address.clone();