diff --git a/mm2src/coins/eth/eth_tests.rs b/mm2src/coins/eth/eth_tests.rs
index c7f1e51d13..b96c8da8dd 100644
--- a/mm2src/coins/eth/eth_tests.rs
+++ b/mm2src/coins/eth/eth_tests.rs
@@ -1,13 +1,13 @@
 use super::*;
 use crate::IguanaPrivKey;
-use common::{block_on, block_on_f01};
+use common::block_on;
 use mm2_core::mm_ctx::MmCtxBuilder;
 
 cfg_native!(
     use crate::eth::for_tests::{eth_coin_for_test, eth_coin_from_keypair};
     use crate::DexFee;
 
-    use common::now_sec;
+    use common::{now_sec, block_on_f01};
     use ethkey::{Generator, Random};
     use mm2_test_helpers::for_tests::{ETH_MAINNET_CHAIN_ID, ETH_MAINNET_NODE, ETH_SEPOLIA_CHAIN_ID, ETH_SEPOLIA_NODES,
                                   ETH_SEPOLIA_TOKEN_CONTRACT};
diff --git a/mm2src/coins/hd_wallet/storage/sqlite_storage.rs b/mm2src/coins/hd_wallet/storage/sqlite_storage.rs
index 898f4c8823..f430eac042 100644
--- a/mm2src/coins/hd_wallet/storage/sqlite_storage.rs
+++ b/mm2src/coins/hd_wallet/storage/sqlite_storage.rs
@@ -101,7 +101,7 @@ impl HDWalletStorageInternalOps for HDWalletSqliteStorage {
     where
         Self: Sized,
     {
-        let shared = ctx.shared_sqlite_conn.as_option().or_mm_err(|| {
+        let shared = ctx.shared_sqlite_conn.get().or_mm_err(|| {
             HDWalletStorageError::Internal("'MmCtx::shared_sqlite_conn' is not initialized".to_owned())
         })?;
         let storage = HDWalletSqliteStorage {
diff --git a/mm2src/coins/lightning/ln_utils.rs b/mm2src/coins/lightning/ln_utils.rs
index 5b4ac5698d..79868908fa 100644
--- a/mm2src/coins/lightning/ln_utils.rs
+++ b/mm2src/coins/lightning/ln_utils.rs
@@ -87,6 +87,7 @@ pub async fn init_db(ctx: &MmArc, ticker: String) -> EnableLightningResult<Sqlit
     let db = SqliteLightningDB::new(
         ticker,
         ctx.sqlite_connection
+            .get()
             .ok_or(MmError::new(EnableLightningError::DbError(
                 "sqlite_connection is not initialized".into(),
             )))?
diff --git a/mm2src/coins/nft/nft_structs.rs b/mm2src/coins/nft/nft_structs.rs
index b10f68d05d..e1412933d4 100644
--- a/mm2src/coins/nft/nft_structs.rs
+++ b/mm2src/coins/nft/nft_structs.rs
@@ -734,14 +734,15 @@ impl NftCtx {
     /// If an `NftCtx` instance doesn't already exist in the MM context, it gets created and cached for subsequent use.
     #[cfg(not(target_arch = "wasm32"))]
     pub(crate) fn from_ctx(ctx: &MmArc) -> Result<Arc<NftCtx>, String> {
-        Ok(try_s!(from_ctx(&ctx.nft_ctx, move || {
+        from_ctx(&ctx.nft_ctx, move || {
             let async_sqlite_connection = ctx
                 .async_sqlite_connection
+                .get()
                 .ok_or("async_sqlite_connection is not initialized".to_owned())?;
             Ok(NftCtx {
                 nft_cache_db: async_sqlite_connection.clone(),
             })
-        })))
+        })
     }
 
     #[cfg(target_arch = "wasm32")]
diff --git a/mm2src/coins/tx_history_storage/sql_tx_history_storage_v2.rs b/mm2src/coins/tx_history_storage/sql_tx_history_storage_v2.rs
index cf0575f973..f5b1312a65 100644
--- a/mm2src/coins/tx_history_storage/sql_tx_history_storage_v2.rs
+++ b/mm2src/coins/tx_history_storage/sql_tx_history_storage_v2.rs
@@ -376,11 +376,12 @@ pub struct SqliteTxHistoryStorage(Arc<Mutex<Connection>>);
 
 impl SqliteTxHistoryStorage {
     pub fn new(ctx: &MmArc) -> Result<Self, MmError<CreateTxHistoryStorageError>> {
-        let sqlite_connection = ctx
-            .sqlite_connection
-            .ok_or(MmError::new(CreateTxHistoryStorageError::Internal(
-                "sqlite_connection is not initialized".to_owned(),
-            )))?;
+        let sqlite_connection =
+            ctx.sqlite_connection
+                .get()
+                .ok_or(MmError::new(CreateTxHistoryStorageError::Internal(
+                    "sqlite_connection is not initialized".to_owned(),
+                )))?;
         Ok(SqliteTxHistoryStorage(sqlite_connection.clone()))
     }
 }
diff --git a/mm2src/coins/utxo/utxo_block_header_storage/mod.rs b/mm2src/coins/utxo/utxo_block_header_storage/mod.rs
index 89266af2f6..c065016176 100644
--- a/mm2src/coins/utxo/utxo_block_header_storage/mod.rs
+++ b/mm2src/coins/utxo/utxo_block_header_storage/mod.rs
@@ -27,7 +27,7 @@ impl Debug for BlockHeaderStorage {
 impl BlockHeaderStorage {
     #[cfg(all(not(test), not(target_arch = "wasm32")))]
     pub(crate) fn new_from_ctx(ctx: MmArc, ticker: String) -> Result<Self, BlockHeaderStorageError> {
-        let sqlite_connection = ctx.sqlite_connection.ok_or(BlockHeaderStorageError::Internal(
+        let sqlite_connection = ctx.sqlite_connection.get().ok_or(BlockHeaderStorageError::Internal(
             "sqlite_connection is not initialized".to_owned(),
         ))?;
         Ok(BlockHeaderStorage {
@@ -50,8 +50,11 @@ impl BlockHeaderStorage {
         use db_common::sqlite::rusqlite::Connection;
         use std::sync::{Arc, Mutex};
 
-        let conn = Arc::new(Mutex::new(Connection::open_in_memory().unwrap()));
-        let conn = ctx.sqlite_connection.clone_or(conn);
+        let conn = ctx
+            .sqlite_connection
+            .get()
+            .cloned()
+            .unwrap_or_else(|| Arc::new(Mutex::new(Connection::open_in_memory().unwrap())));
 
         Ok(BlockHeaderStorage {
             inner: Box::new(SqliteBlockHeadersStorage { ticker, conn }),
diff --git a/mm2src/coins/z_coin/storage/blockdb/blockdb_sql_storage.rs b/mm2src/coins/z_coin/storage/blockdb/blockdb_sql_storage.rs
index 7523360807..fea9a93277 100644
--- a/mm2src/coins/z_coin/storage/blockdb/blockdb_sql_storage.rs
+++ b/mm2src/coins/z_coin/storage/blockdb/blockdb_sql_storage.rs
@@ -49,10 +49,9 @@ impl BlockDbImpl {
         async_blocking(move || {
             let conn = Connection::open(path).map_to_mm(|err| ZcoinStorageError::DbError(err.to_string()))?;
             let conn = Arc::new(Mutex::new(conn));
-            let conn_clone = conn.clone();
-            let conn_clone = conn_clone.lock().unwrap();
-            run_optimization_pragmas(&conn_clone).map_to_mm(|err| ZcoinStorageError::DbError(err.to_string()))?;
-            conn_clone
+            let conn_lock = conn.lock().unwrap();
+            run_optimization_pragmas(&conn_lock).map_to_mm(|err| ZcoinStorageError::DbError(err.to_string()))?;
+            conn_lock
                 .execute(
                     "CREATE TABLE IF NOT EXISTS compactblocks (
             height INTEGER PRIMARY KEY,
@@ -61,6 +60,7 @@ impl BlockDbImpl {
                     [],
                 )
                 .map_to_mm(|err| ZcoinStorageError::DbError(err.to_string()))?;
+            drop(conn_lock);
 
             Ok(Self { db: conn, ticker })
         })
@@ -73,11 +73,12 @@ impl BlockDbImpl {
         async_blocking(move || {
             let conn = ctx
                 .sqlite_connection
-                .clone_or(Arc::new(Mutex::new(Connection::open_in_memory().unwrap())));
-            let conn_clone = conn.clone();
-            let conn_clone = conn_clone.lock().unwrap();
-            run_optimization_pragmas(&conn_clone).map_err(|err| ZcoinStorageError::DbError(err.to_string()))?;
-            conn_clone
+                .get()
+                .cloned()
+                .unwrap_or_else(|| Arc::new(Mutex::new(Connection::open_in_memory().unwrap())));
+            let conn_lock = conn.lock().unwrap();
+            run_optimization_pragmas(&conn_lock).map_err(|err| ZcoinStorageError::DbError(err.to_string()))?;
+            conn_lock
                 .execute(
                     "CREATE TABLE IF NOT EXISTS compactblocks (
             height INTEGER PRIMARY KEY,
@@ -86,6 +87,7 @@ impl BlockDbImpl {
                     [],
                 )
                 .map_to_mm(|err| ZcoinStorageError::DbError(err.to_string()))?;
+            drop(conn_lock);
 
             Ok(BlockDbImpl { db: conn, ticker })
         })
diff --git a/mm2src/crypto/src/crypto_ctx.rs b/mm2src/crypto/src/crypto_ctx.rs
index 92ac1f2196..ffc83603a6 100644
--- a/mm2src/crypto/src/crypto_ctx.rs
+++ b/mm2src/crypto/src/crypto_ctx.rs
@@ -316,10 +316,12 @@ impl CryptoCtx {
         *ctx_field = Some(result.clone());
         drop(ctx_field);
 
-        ctx.rmd160.pin(rmd160).map_to_mm(CryptoInitError::Internal)?;
+        ctx.rmd160
+            .set(rmd160)
+            .map_to_mm(|_| CryptoInitError::Internal("Already Initialized".to_string()))?;
         ctx.shared_db_id
-            .pin(shared_db_id)
-            .map_to_mm(CryptoInitError::Internal)?;
+            .set(shared_db_id)
+            .map_to_mm(|_| CryptoInitError::Internal("Already Initialized".to_string()))?;
 
         info!("Public key hash: {rmd160}");
         info!("Shared Database ID: {shared_db_id}");
diff --git a/mm2src/mm2_bin_lib/src/lib.rs b/mm2src/mm2_bin_lib/src/lib.rs
index c78233e64a..7ac292aa63 100644
--- a/mm2src/mm2_bin_lib/src/lib.rs
+++ b/mm2src/mm2_bin_lib/src/lib.rs
@@ -41,7 +41,7 @@ fn mm2_status() -> MainStatus {
         Err(_) => return MainStatus::NoRpc,
     };
 
-    if ctx.rpc_started.copy_or(false) {
+    if *ctx.rpc_started.get().unwrap_or(&false) {
         MainStatus::RpcIsUp
     } else {
         MainStatus::NoRpc
diff --git a/mm2src/mm2_bin_lib/src/mm2_wasm_lib.rs b/mm2src/mm2_bin_lib/src/mm2_wasm_lib.rs
index ee56bd4045..f878e1b914 100644
--- a/mm2src/mm2_bin_lib/src/mm2_wasm_lib.rs
+++ b/mm2src/mm2_bin_lib/src/mm2_wasm_lib.rs
@@ -216,7 +216,7 @@ pub async fn mm2_rpc(payload: JsValue) -> Result<JsValue, JsValue> {
         Err(_) => return Err(Mm2RpcErr::NotRunning.into()),
     };
 
-    let wasm_rpc = ctx.wasm_rpc.ok_or(JsValue::from(Mm2RpcErr::NotRunning))?;
+    let wasm_rpc = ctx.wasm_rpc.get().ok_or(JsValue::from(Mm2RpcErr::NotRunning))?;
     let response: Mm2RpcResponse = wasm_rpc.request(request_json).await.into();
 
     serialize_to_js(&response).map_err(|e| {
diff --git a/mm2src/mm2_core/Cargo.toml b/mm2src/mm2_core/Cargo.toml
index d0df9dbe7c..78fffea53b 100644
--- a/mm2src/mm2_core/Cargo.toml
+++ b/mm2src/mm2_core/Cargo.toml
@@ -15,6 +15,7 @@ common = { path = "../common" }
 db_common = { path = "../db_common" }
 derive_more = "0.99"
 futures = { version = "0.3", package = "futures", features = ["compat", "async-await", "thread-pool"] }
+gstuff = { version = "0.7", features = ["nightly"] }
 hex = "0.4.2"
 lazy_static = "1.4"
 libp2p = { git = "https://github.com/KomodoPlatform/rust-libp2p.git", tag = "k-0.52.4", default-features = false, features = ["identify"] }
@@ -31,13 +32,11 @@ shared_ref_counter = { path = "../common/shared_ref_counter" }
 uuid = { version = "1.2.2", features = ["fast-rng", "serde", "v4"] }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
-gstuff = { version = "0.7", features = ["nightly"] }
 instant = { version = "0.1.12", features = ["wasm-bindgen"] }
 mm2_rpc = { path = "../mm2_rpc", features = [ "rpc_facilities" ] }
 wasm-bindgen-test = { version = "0.3.2" }
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 rustls = { version = "0.21", default-features = false }
-gstuff = { version = "0.7", features = ["nightly"] }
 instant = "0.1.12"
 tokio = { version = "1.20", features = ["io-util", "rt-multi-thread", "net"] }
diff --git a/mm2src/mm2_core/src/mm_ctx.rs b/mm2src/mm2_core/src/mm_ctx.rs
index 8c417f2ce1..0a1afb2eea 100644
--- a/mm2src/mm2_core/src/mm_ctx.rs
+++ b/mm2src/mm2_core/src/mm_ctx.rs
@@ -7,7 +7,7 @@ use common::{executor::{abortable_queue::{AbortableQueue, WeakSpawner},
              expirable_map::ExpirableMap};
 use futures::channel::oneshot;
 use futures::lock::Mutex as AsyncMutex;
-use gstuff::{try_s, Constructible, ERR, ERRL};
+use gstuff::{try_s, ERR, ERRL};
 use lazy_static::lazy_static;
 use libp2p::PeerId;
 use mm2_event_stream::{controller::Controller, Event, EventStreamConfiguration};
@@ -22,7 +22,7 @@ use std::collections::HashSet;
 use std::fmt;
 use std::future::Future;
 use std::ops::Deref;
-use std::sync::{Arc, Mutex};
+use std::sync::{Arc, Mutex, OnceLock};
 
 use crate::data_asker::DataAsker;
 
@@ -76,9 +76,9 @@ pub struct MmCtx {
     /// Should be refactored away in the future. State should always be valid.
     /// If there are things that are loaded in background then they should be separately optional,
     /// without invalidating the entire state.
-    pub initialized: Constructible<bool>,
+    pub initialized: OnceLock<bool>,
     /// True if the RPC HTTP server was started.
-    pub rpc_started: Constructible<bool>,
+    pub rpc_started: OnceLock<bool>,
     /// Controller for continuously streaming data using streaming channels of `mm2_event_stream`.
     pub stream_channel_controller: Controller<Event>,
     /// Data transfer bridge between server and client where server (which is the mm2 runtime) initiates the request.
@@ -86,10 +86,10 @@ pub struct MmCtx {
     /// Configuration of event streaming used for SSE.
     pub event_stream_configuration: Option<EventStreamConfiguration>,
     /// True if the MarketMaker instance needs to stop.
-    pub stop: Constructible<bool>,
+    pub stop: OnceLock<bool>,
     /// Unique context identifier, allowing us to more easily pass the context through the FFI boundaries.  
     /// 0 if the handler ID is allocated yet.
-    pub ffi_handle: Constructible<u32>,
+    pub ffi_handle: OnceLock<u32>,
     /// The context belonging to the `ordermatch` mod: `OrdermatchContext`.
     pub ordermatch_ctx: Mutex<Option<Arc<dyn Any + 'static + Send + Sync>>>,
     pub rate_limit_ctx: Mutex<Option<Arc<dyn Any + 'static + Send + Sync>>>,
@@ -104,10 +104,10 @@ pub struct MmCtx {
     pub crypto_ctx: Mutex<Option<Arc<dyn Any + 'static + Send + Sync>>>,
     /// RIPEMD160(SHA256(x)) where x is secp256k1 pubkey derived from passphrase.
     /// This hash is **unique** among Iguana and each HD accounts derived from the same passphrase.
-    pub rmd160: Constructible<H160>,
+    pub rmd160: OnceLock<H160>,
     /// A shared DB identifier - RIPEMD160(SHA256(x)) where x is secp256k1 pubkey derived from (passphrase + magic salt).
     /// This hash is **the same** for Iguana and all HD accounts derived from the same passphrase.
-    pub shared_db_id: Constructible<H160>,
+    pub shared_db_id: OnceLock<H160>,
     /// Coins that should be enabled to kick start the interrupted swaps and orders.
     pub coins_needed_for_kick_start: Mutex<HashSet<String>>,
     /// The context belonging to the `lp_swap` mod: `SwapsContext`.
@@ -115,19 +115,19 @@ pub struct MmCtx {
     /// The context belonging to the `lp_stats` mod: `StatsContext`
     pub stats_ctx: Mutex<Option<Arc<dyn Any + 'static + Send + Sync>>>,
     /// Wallet name for this mm2 instance. Optional for backwards compatibility.
-    pub wallet_name: Constructible<Option<String>>,
+    pub wallet_name: OnceLock<Option<String>>,
     /// The context belonging to the `lp_wallet` mod: `WalletsContext`.
     #[cfg(target_arch = "wasm32")]
     pub wallets_ctx: Mutex<Option<Arc<dyn Any + 'static + Send + Sync>>>,
     /// The RPC sender forwarding requests to writing part of underlying stream.
     #[cfg(target_arch = "wasm32")]
-    pub wasm_rpc: Constructible<WasmRpcSender>,
+    pub wasm_rpc: OnceLock<WasmRpcSender>,
     /// Deprecated, please use `async_sqlite_connection` for new implementations.
     #[cfg(not(target_arch = "wasm32"))]
-    pub sqlite_connection: Constructible<Arc<Mutex<Connection>>>,
+    pub sqlite_connection: OnceLock<Arc<Mutex<Connection>>>,
     /// Deprecated, please create `shared_async_sqlite_conn` for new implementations and call db `KOMODEFI-shared.db`.
     #[cfg(not(target_arch = "wasm32"))]
-    pub shared_sqlite_conn: Constructible<Arc<Mutex<Connection>>>,
+    pub shared_sqlite_conn: OnceLock<Arc<Mutex<Connection>>>,
     pub mm_version: String,
     pub datetime: String,
     pub mm_init_ctx: Mutex<Option<Arc<dyn Any + 'static + Send + Sync>>>,
@@ -144,7 +144,7 @@ pub struct MmCtx {
     pub nft_ctx: Mutex<Option<Arc<dyn Any + 'static + Send + Sync>>>,
     /// asynchronous handle for rusqlite connection.
     #[cfg(not(target_arch = "wasm32"))]
-    pub async_sqlite_connection: Constructible<Arc<AsyncMutex<AsyncConnection>>>,
+    pub async_sqlite_connection: OnceLock<Arc<AsyncMutex<AsyncConnection>>>,
     /// Links the RPC context to the P2P context to handle health check responses.
     pub healthcheck_response_handler: AsyncMutex<ExpirableMap<PeerId, oneshot::Sender<()>>>,
 }
@@ -155,13 +155,13 @@ impl MmCtx {
             conf: Json::Object(json::Map::new()),
             log: log::LogArc::new(log),
             metrics: MetricsArc::new(),
-            initialized: Constructible::default(),
-            rpc_started: Constructible::default(),
+            initialized: OnceLock::default(),
+            rpc_started: OnceLock::default(),
             stream_channel_controller: Controller::new(),
             data_asker: DataAsker::default(),
             event_stream_configuration: None,
-            stop: Constructible::default(),
-            ffi_handle: Constructible::default(),
+            stop: OnceLock::default(),
+            ffi_handle: OnceLock::default(),
             ordermatch_ctx: Mutex::new(None),
             rate_limit_ctx: Mutex::new(None),
             simple_market_maker_bot_ctx: Mutex::new(None),
@@ -172,20 +172,20 @@ impl MmCtx {
             coins_ctx: Mutex::new(None),
             coins_activation_ctx: Mutex::new(None),
             crypto_ctx: Mutex::new(None),
-            rmd160: Constructible::default(),
-            shared_db_id: Constructible::default(),
+            rmd160: OnceLock::default(),
+            shared_db_id: OnceLock::default(),
             coins_needed_for_kick_start: Mutex::new(HashSet::new()),
             swaps_ctx: Mutex::new(None),
             stats_ctx: Mutex::new(None),
-            wallet_name: Constructible::default(),
+            wallet_name: OnceLock::default(),
             #[cfg(target_arch = "wasm32")]
             wallets_ctx: Mutex::new(None),
             #[cfg(target_arch = "wasm32")]
-            wasm_rpc: Constructible::default(),
+            wasm_rpc: OnceLock::default(),
             #[cfg(not(target_arch = "wasm32"))]
-            sqlite_connection: Constructible::default(),
+            sqlite_connection: OnceLock::default(),
             #[cfg(not(target_arch = "wasm32"))]
-            shared_sqlite_conn: Constructible::default(),
+            shared_sqlite_conn: OnceLock::default(),
             mm_version: "".into(),
             datetime: "".into(),
             mm_init_ctx: Mutex::new(None),
@@ -195,7 +195,7 @@ impl MmCtx {
             db_namespace: DbNamespaceId::Main,
             nft_ctx: Mutex::new(None),
             #[cfg(not(target_arch = "wasm32"))]
-            async_sqlite_connection: Constructible::default(),
+            async_sqlite_connection: OnceLock::default(),
             healthcheck_response_handler: AsyncMutex::new(ExpirableMap::default()),
         }
     }
@@ -204,14 +204,14 @@ impl MmCtx {
         lazy_static! {
             static ref DEFAULT: H160 = [0; 20].into();
         }
-        self.rmd160.or(&|| &*DEFAULT)
+        self.rmd160.get().unwrap_or(&*DEFAULT)
     }
 
     pub fn shared_db_id(&self) -> &H160 {
         lazy_static! {
             static ref DEFAULT: H160 = [0; 20].into();
         }
-        self.shared_db_id.or(&|| &*DEFAULT)
+        self.shared_db_id.get().unwrap_or(&*DEFAULT)
     }
 
     #[cfg(not(target_arch = "wasm32"))]
@@ -346,7 +346,7 @@ impl MmCtx {
     pub fn spawner(&self) -> MmFutSpawner { MmFutSpawner::new(&self.abortable_system) }
 
     /// True if the MarketMaker instance needs to stop.
-    pub fn is_stopping(&self) -> bool { self.stop.copy_or(false) }
+    pub fn is_stopping(&self) -> bool { *self.stop.get().unwrap_or(&false) }
 
     pub fn gui(&self) -> Option<&str> { self.conf["gui"].as_str() }
 
@@ -357,7 +357,10 @@ impl MmCtx {
         let sqlite_file_path = self.dbdir().join("MM2.db");
         log_sqlite_file_open_attempt(&sqlite_file_path);
         let connection = try_s!(Connection::open(sqlite_file_path));
-        try_s!(self.sqlite_connection.pin(Arc::new(Mutex::new(connection))));
+        try_s!(self
+            .sqlite_connection
+            .set(Arc::new(Mutex::new(connection)))
+            .map_err(|_| "Already initialized".to_string()));
         Ok(())
     }
 
@@ -366,7 +369,10 @@ impl MmCtx {
         let sqlite_file_path = self.shared_dbdir().join("MM2-shared.db");
         log_sqlite_file_open_attempt(&sqlite_file_path);
         let connection = try_s!(Connection::open(sqlite_file_path));
-        try_s!(self.shared_sqlite_conn.pin(Arc::new(Mutex::new(connection))));
+        try_s!(self
+            .shared_sqlite_conn
+            .set(Arc::new(Mutex::new(connection)))
+            .map_err(|_| "Already initialized".to_string()));
         Ok(())
     }
 
@@ -375,19 +381,23 @@ impl MmCtx {
         let sqlite_file_path = self.dbdir().join("KOMODEFI.db");
         log_sqlite_file_open_attempt(&sqlite_file_path);
         let async_conn = try_s!(AsyncConnection::open(sqlite_file_path).await);
-        try_s!(self.async_sqlite_connection.pin(Arc::new(AsyncMutex::new(async_conn))));
+        try_s!(self
+            .async_sqlite_connection
+            .set(Arc::new(AsyncMutex::new(async_conn)))
+            .map_err(|_| "Already initialized".to_string()));
         Ok(())
     }
 
     #[cfg(not(target_arch = "wasm32"))]
     pub fn sqlite_conn_opt(&self) -> Option<MutexGuard<Connection>> {
-        self.sqlite_connection.as_option().map(|conn| conn.lock().unwrap())
+        self.sqlite_connection.get().map(|conn| conn.lock().unwrap())
     }
 
     #[cfg(not(target_arch = "wasm32"))]
     pub fn sqlite_connection(&self) -> MutexGuard<Connection> {
         self.sqlite_connection
-            .or(&|| panic!("sqlite_connection is not initialized"))
+            .get()
+            .expect("sqlite_connection is not initialized")
             .lock()
             .unwrap()
     }
@@ -395,7 +405,8 @@ impl MmCtx {
     #[cfg(not(target_arch = "wasm32"))]
     pub fn shared_sqlite_conn(&self) -> MutexGuard<Connection> {
         self.shared_sqlite_conn
-            .or(&|| panic!("shared_sqlite_conn is not initialized"))
+            .get()
+            .expect("shared_sqlite_conn is not initialized")
             .lock()
             .unwrap()
     }
@@ -409,7 +420,7 @@ impl Drop for MmCtx {
     fn drop(&mut self) {
         let ffi_handle = self
             .ffi_handle
-            .as_option()
+            .get()
             .map(|handle| handle.to_string())
             .unwrap_or_else(|| "UNKNOWN".to_owned());
         log::info!("MmCtx ({}) has been dropped", ffi_handle)
@@ -512,7 +523,7 @@ impl MmArc {
         #[cfg(not(target_arch = "wasm32"))]
         try_s!(self.close_async_connection().await);
 
-        try_s!(self.stop.pin(true));
+        try_s!(self.stop.set(true));
 
         // Notify shutdown listeners.
         self.graceful_shutdown_registry.abort_all().warn_log();
@@ -527,7 +538,7 @@ impl MmArc {
 
     #[cfg(not(target_arch = "wasm32"))]
     async fn close_async_connection(&self) -> Result<(), db_common::async_sql_conn::AsyncConnError> {
-        if let Some(async_conn) = self.async_sqlite_connection.as_option() {
+        if let Some(async_conn) = self.async_sqlite_connection.get() {
             let mut conn = async_conn.lock().await;
             conn.close().await?;
         }
@@ -560,7 +571,7 @@ impl MmArc {
     /// Unique context identifier, allowing us to more easily pass the context through the FFI boundaries.
     pub fn ffi_handle(&self) -> Result<u32, String> {
         let mut mm_ctx_ffi = try_s!(MM_CTX_FFI.lock());
-        if let Some(have) = self.ffi_handle.as_option() {
+        if let Some(have) = self.ffi_handle.get() {
             return Ok(*have);
         }
         let mut tries = 0;
@@ -579,7 +590,7 @@ impl MmArc {
                 Entry::Occupied(_) => continue, // Try another ID.
                 Entry::Vacant(ve) => {
                     ve.insert(self.weak());
-                    try_s!(self.ffi_handle.pin(rid));
+                    try_s!(self.ffi_handle.set(rid));
                     return Ok(rid);
                 },
             }
@@ -698,25 +709,19 @@ impl SpawnAbortable for MmFutSpawner {
 ///
 /// * `ctx_field` - A dedicated crate context field in `MmCtx`, such as the `MmCtx::portfolio_ctx`.
 /// * `constructor` - Generates the initial crate context.
-pub fn from_ctx<T, C>(
-    ctx_field: &Mutex<Option<Arc<dyn Any + 'static + Send + Sync>>>,
-    constructor: C,
-) -> Result<Arc<T>, String>
+pub fn from_ctx<T, F>(ctx: &Mutex<Option<Arc<dyn Any + Send + Sync>>>, init: F) -> Result<Arc<T>, String>
 where
-    C: FnOnce() -> Result<T, String>,
     T: 'static + Send + Sync,
+    F: FnOnce() -> Result<T, String>,
 {
-    let mut ctx_field = try_s!(ctx_field.lock());
-    if let Some(ref ctx) = *ctx_field {
-        let ctx: Arc<T> = match ctx.clone().downcast() {
-            Ok(p) => p,
-            Err(_) => return ERR!("Error casting the context field"),
-        };
-        return Ok(ctx);
+    let mut guard = try_s!(ctx.lock());
+    if let Some(ctx) = guard.as_ref() {
+        return ctx.clone().downcast().map_err(|_| "Context type mismatch".to_string());
     }
-    let arc = Arc::new(try_s!(constructor()));
-    *ctx_field = Some(arc.clone());
-    Ok(arc)
+
+    let new_ctx = Arc::new(init()?);
+    *guard = Some(new_ctx.clone());
+    Ok(new_ctx)
 }
 
 #[derive(Default)]
diff --git a/mm2src/mm2_gui_storage/src/account/storage/sqlite_storage.rs b/mm2src/mm2_gui_storage/src/account/storage/sqlite_storage.rs
index 916854de63..4e2be2acac 100644
--- a/mm2src/mm2_gui_storage/src/account/storage/sqlite_storage.rs
+++ b/mm2src/mm2_gui_storage/src/account/storage/sqlite_storage.rs
@@ -118,7 +118,7 @@ impl SqliteAccountStorage {
     pub(crate) fn new(ctx: &MmArc) -> AccountStorageResult<SqliteAccountStorage> {
         let shared = ctx
             .sqlite_connection
-            .as_option()
+            .get()
             .or_mm_err(|| AccountStorageError::Internal("'MmCtx::sqlite_connection' is not initialized".to_owned()))?;
         Ok(SqliteAccountStorage {
             conn: Arc::clone(shared),
diff --git a/mm2src/mm2_main/src/lp_native_dex.rs b/mm2src/mm2_main/src/lp_native_dex.rs
index 8e1e91ec13..1e5f7feff0 100644
--- a/mm2src/mm2_main/src/lp_native_dex.rs
+++ b/mm2src/mm2_main/src/lp_native_dex.rs
@@ -476,7 +476,9 @@ pub async fn lp_init_continue(ctx: MmArc) -> MmInitResult<()> {
     let balance_update_ordermatch_handler = BalanceUpdateOrdermatchHandler::new(ctx.clone());
     register_balance_update_handler(ctx.clone(), Box::new(balance_update_ordermatch_handler)).await;
 
-    ctx.initialized.pin(true).map_to_mm(MmInitError::Internal)?;
+    ctx.initialized
+        .set(true)
+        .map_to_mm(|_| MmInitError::Internal("Already Initialized".to_string()))?;
 
     // launch kickstart threads before RPC is available, this will prevent the API user to place
     // an order and start new swap that might get started 2 times because of kick-start
diff --git a/mm2src/mm2_main/src/lp_wallet.rs b/mm2src/mm2_main/src/lp_wallet.rs
index 559821a26a..20a154b28c 100644
--- a/mm2src/mm2_main/src/lp_wallet.rs
+++ b/mm2src/mm2_main/src/lp_wallet.rs
@@ -305,8 +305,8 @@ fn initialize_crypto_context(ctx: &MmArc, passphrase: &str) -> WalletInitResult<
 pub(crate) async fn initialize_wallet_passphrase(ctx: &MmArc) -> WalletInitResult<()> {
     let (wallet_name, passphrase) = deserialize_wallet_config(ctx)?;
     ctx.wallet_name
-        .pin(wallet_name.clone())
-        .map_to_mm(WalletInitError::InternalError)?;
+        .set(wallet_name.clone())
+        .map_to_mm(|_| WalletInitError::InternalError("Already Initialized".to_string()))?;
     let passphrase = process_passphrase_logic(ctx, wallet_name, passphrase).await?;
 
     if let Some(passphrase) = passphrase {
@@ -541,7 +541,7 @@ pub async fn get_wallet_names_rpc(ctx: MmArc, _req: Json) -> MmResult<GetWalletN
     let wallets = read_all_wallet_names(&ctx).await?.sorted().collect();
     // Note: `ok_or` is used here on `Constructible<Option<String>>` to handle the case where the wallet name is not set.
     // `wallet_name` can be `None` in the case of no-login mode.
-    let activated_wallet = ctx.wallet_name.ok_or(GetWalletsError::Internal(
+    let activated_wallet = ctx.wallet_name.get().ok_or(GetWalletsError::Internal(
         "`wallet_name` not initialized yet!".to_string(),
     ))?;
 
diff --git a/mm2src/mm2_main/src/lp_wallet/mnemonics_storage.rs b/mm2src/mm2_main/src/lp_wallet/mnemonics_storage.rs
index c873b2d5ff..e779f7b86a 100644
--- a/mm2src/mm2_main/src/lp_wallet/mnemonics_storage.rs
+++ b/mm2src/mm2_main/src/lp_wallet/mnemonics_storage.rs
@@ -47,6 +47,7 @@ pub(super) async fn save_encrypted_passphrase(
 pub(super) async fn read_encrypted_passphrase_if_available(ctx: &MmArc) -> WalletsStorageResult<Option<EncryptedData>> {
     let wallet_name = ctx
         .wallet_name
+        .get()
         .ok_or(WalletsStorageError::Internal(
             "`wallet_name` not initialized yet!".to_string(),
         ))?
diff --git a/mm2src/mm2_main/src/lp_wallet/mnemonics_wasm_db.rs b/mm2src/mm2_main/src/lp_wallet/mnemonics_wasm_db.rs
index a815bfcca1..fa66cada1c 100644
--- a/mm2src/mm2_main/src/lp_wallet/mnemonics_wasm_db.rs
+++ b/mm2src/mm2_main/src/lp_wallet/mnemonics_wasm_db.rs
@@ -126,6 +126,7 @@ pub(super) async fn read_encrypted_passphrase_if_available(ctx: &MmArc) -> Walle
 
     let wallet_name = ctx
         .wallet_name
+        .get()
         .ok_or(WalletsDBError::Internal(
             "`wallet_name` not initialized yet!".to_string(),
         ))?
diff --git a/mm2src/mm2_main/src/mm2.rs b/mm2src/mm2_main/src/mm2.rs
index dd7c7bed27..d168800871 100644
--- a/mm2src/mm2_main/src/mm2.rs
+++ b/mm2src/mm2_main/src/mm2.rs
@@ -277,7 +277,7 @@ pub fn mm2_main(version: String, datetime: String) {
     }
 
     if first_arg == Some("--version") || first_arg == Some("-v") || first_arg == Some("version") {
-        println!("AtomicDEX API: {version}");
+        println!("Komodo DeFi Framework: {version}");
         return;
     }
 
@@ -291,7 +291,7 @@ pub fn mm2_main(version: String, datetime: String) {
         return;
     }
 
-    log!("AtomicDEX API {} DT {}", version, datetime);
+    log!("Komodo DeFi Framework {} DT {}", version, datetime);
 
     if let Err(err) = run_lp_main(first_arg, &|_| (), version, datetime) {
         log!("{}", err);
diff --git a/mm2src/mm2_main/src/ordermatch_tests.rs b/mm2src/mm2_main/src/ordermatch_tests.rs
index 1ac83697af..3bf81d6370 100644
--- a/mm2src/mm2_main/src/ordermatch_tests.rs
+++ b/mm2src/mm2_main/src/ordermatch_tests.rs
@@ -1055,7 +1055,10 @@ fn test_cancel_by_single_coin() {
     let rx = prepare_for_cancel_by(&ctx);
 
     let connection = Connection::open_in_memory().unwrap();
-    let _ = ctx.sqlite_connection.pin(Arc::new(Mutex::new(connection)));
+    let _ = ctx
+        .sqlite_connection
+        .set(Arc::new(Mutex::new(connection)))
+        .map_err(|_| "Already Initialized".to_string());
 
     delete_my_maker_order.mock_safe(|_, _, _| MockResult::Return(Box::new(futures01::future::ok(()))));
     delete_my_taker_order.mock_safe(|_, _, _| MockResult::Return(Box::new(futures01::future::ok(()))));
@@ -1074,7 +1077,10 @@ fn test_cancel_by_pair() {
     let rx = prepare_for_cancel_by(&ctx);
 
     let connection = Connection::open_in_memory().unwrap();
-    let _ = ctx.sqlite_connection.pin(Arc::new(Mutex::new(connection)));
+    let _ = ctx
+        .sqlite_connection
+        .set(Arc::new(Mutex::new(connection)))
+        .map_err(|_| "Already Initialized".to_string());
 
     delete_my_maker_order.mock_safe(|_, _, _| MockResult::Return(Box::new(futures01::future::ok(()))));
     delete_my_taker_order.mock_safe(|_, _, _| MockResult::Return(Box::new(futures01::future::ok(()))));
@@ -1097,7 +1103,10 @@ fn test_cancel_by_all() {
     let rx = prepare_for_cancel_by(&ctx);
 
     let connection = Connection::open_in_memory().unwrap();
-    let _ = ctx.sqlite_connection.pin(Arc::new(Mutex::new(connection)));
+    let _ = ctx
+        .sqlite_connection
+        .set(Arc::new(Mutex::new(connection)))
+        .map_err(|_| "Already Initialized".to_string());
 
     delete_my_maker_order.mock_safe(|_, _, _| MockResult::Return(Box::new(futures01::future::ok(()))));
     delete_my_taker_order.mock_safe(|_, _, _| MockResult::Return(Box::new(futures01::future::ok(()))));
diff --git a/mm2src/mm2_main/src/rpc.rs b/mm2src/mm2_main/src/rpc.rs
index 85b61db612..f109621f3f 100644
--- a/mm2src/mm2_main/src/rpc.rs
+++ b/mm2src/mm2_main/src/rpc.rs
@@ -427,7 +427,7 @@ pub extern "C" fn spawn_rpc(ctx_h: u32) {
                         $port,
                         now_sec()
                     );
-                    let _ = $ctx.rpc_started.pin(true);
+                    let _ = $ctx.rpc_started.set(true);
                     server
                 });
             }
@@ -496,7 +496,7 @@ pub fn spawn_rpc(ctx_h: u32) {
     use std::sync::Mutex;
 
     let ctx = MmArc::from_ffi_handle(ctx_h).expect("No context");
-    if ctx.wasm_rpc.is_some() {
+    if ctx.wasm_rpc.get().is_some() {
         error!("RPC is initialized already");
         return;
     }
@@ -529,12 +529,12 @@ pub fn spawn_rpc(ctx_h: u32) {
     ctx.spawner().spawn(fut);
 
     // even if the [`MmCtx::wasm_rpc`] is initialized already, the spawned future above will be shutdown
-    if let Err(e) = ctx.wasm_rpc.pin(request_tx) {
-        error!("'MmCtx::wasm_rpc' is initialized already: {}", e);
+    if ctx.wasm_rpc.set(request_tx).is_err() {
+        error!("'MmCtx::wasm_rpc' is initialized already");
         return;
     };
-    if let Err(e) = ctx.rpc_started.pin(true) {
-        error!("'MmCtx::rpc_started' is set already: {}", e);
+    if ctx.rpc_started.set(true).is_err() {
+        error!("'MmCtx::rpc_started' is set already");
         return;
     }
 
diff --git a/mm2src/mm2_main/tests/docker_tests/swap_watcher_tests.rs b/mm2src/mm2_main/tests/docker_tests/swap_watcher_tests.rs
index 49abc5c77f..43eb715324 100644
--- a/mm2src/mm2_main/tests/docker_tests/swap_watcher_tests.rs
+++ b/mm2src/mm2_main/tests/docker_tests/swap_watcher_tests.rs
@@ -3300,5 +3300,5 @@ fn test_watcher_reward() {
 
     let watcher_reward =
         block_on(utxo_coin.get_maker_watcher_reward(&MmCoinEnum::UtxoCoin(utxo_coin.clone()), None, timeout)).unwrap();
-    assert!(matches!(watcher_reward, None));
+    assert!(watcher_reward.is_none());
 }
diff --git a/mm2src/mm2_test_helpers/src/for_tests.rs b/mm2src/mm2_test_helpers/src/for_tests.rs
index 880edc777a..ecaa470b8e 100644
--- a/mm2src/mm2_test_helpers/src/for_tests.rs
+++ b/mm2src/mm2_test_helpers/src/for_tests.rs
@@ -241,7 +241,11 @@ pub const ETH_MAINNET_NODE: &str = "https://mainnet.infura.io/v3/c01c1b4cf666425
 pub const ETH_MAINNET_CHAIN_ID: u64 = 1;
 pub const ETH_MAINNET_SWAP_CONTRACT: &str = "0x24abe4c71fc658c91313b6552cd40cd808b3ea80";
 
-pub const ETH_SEPOLIA_NODES: &[&str] = &["https://ethereum-sepolia-rpc.publicnode.com","https://rpc2.sepolia.org","https://1rpc.io/sepolia"];
+pub const ETH_SEPOLIA_NODES: &[&str] = &[
+    "https://ethereum-sepolia-rpc.publicnode.com",
+    "https://rpc2.sepolia.org",
+    "https://1rpc.io/sepolia",
+];
 pub const ETH_SEPOLIA_CHAIN_ID: u64 = 11155111;
 pub const ETH_SEPOLIA_SWAP_CONTRACT: &str = "0xeA6D65434A15377081495a9E7C5893543E7c32cB";
 pub const ETH_SEPOLIA_TOKEN_CONTRACT: &str = "0x09d0d71FBC00D7CCF9CFf132f5E6825C88293F19";
@@ -1129,10 +1133,16 @@ pub fn mm_ctx_with_custom_db_with_conf(conf: Option<Json>) -> MmArc {
     let ctx = ctx_builder.into_mm_arc();
 
     let connection = Connection::open_in_memory().unwrap();
-    let _ = ctx.sqlite_connection.pin(Arc::new(Mutex::new(connection)));
+    let _ = ctx
+        .sqlite_connection
+        .set(Arc::new(Mutex::new(connection)))
+        .map_err(|_| "Already Initialized".to_string());
 
     let connection = Connection::open_in_memory().unwrap();
-    let _ = ctx.shared_sqlite_conn.pin(Arc::new(Mutex::new(connection)));
+    let _ = ctx
+        .shared_sqlite_conn
+        .set(Arc::new(Mutex::new(connection)))
+        .map_err(|_| "Already Initialized".to_string());
 
     ctx
 }
@@ -1146,7 +1156,10 @@ pub async fn mm_ctx_with_custom_async_db() -> MmArc {
     let ctx = MmCtxBuilder::new().into_mm_arc();
 
     let connection = AsyncConnection::open_in_memory().await.unwrap();
-    let _ = ctx.async_sqlite_connection.pin(Arc::new(AsyncMutex::new(connection)));
+    let _ = ctx
+        .async_sqlite_connection
+        .set(Arc::new(AsyncMutex::new(connection)))
+        .map_err(|_| "Already Initialized".to_string());
 
     ctx
 }
@@ -1428,8 +1441,7 @@ impl MarketMakerIt {
         }
 
         let ctx = {
-            let builder = MmCtxBuilder::new()
-                .with_conf(conf.clone());
+            let builder = MmCtxBuilder::new().with_conf(conf.clone());
 
             let builder = if let Some(ns) = db_namespace_id {
                 builder.with_test_db_namespace_with_id(ns)
@@ -1522,7 +1534,7 @@ impl MarketMakerIt {
         let wasm_rpc = self
             .ctx
             .wasm_rpc
-            .as_option()
+            .get()
             .expect("'MmCtx::rpc' must be initialized already");
         match wasm_rpc.request(payload.clone()).await {
             // Please note a new type of error will be introduced soon.