Revert "chore(ctx): replace gstuff constructible with oncelock (#2267)"

This reverts commit ac926dd

Author: shamardy

mm2src/coins/eth/eth_tests.rs

@@ -1,13 +1,13 @@
 use super::*;
 use crate::IguanaPrivKey;
-use common::block_on;
+use common::{block_on, block_on_f01};
 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, block_on_f01};
+    use common::now_sec;
     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};

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.get().or_mm_err(|| {
+        let shared = ctx.shared_sqlite_conn.as_option().or_mm_err(|| {
             HDWalletStorageError::Internal("'MmCtx::shared_sqlite_conn' is not initialized".to_owned())
         })?;
         let storage = HDWalletSqliteStorage {

mm2src/coins/lightning/ln_utils.rs

@@ -87,7 +87,6 @@ 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(),
             )))?

mm2src/coins/nft/nft_structs.rs

@@ -734,15 +734,14 @@ 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> {
-        from_ctx(&ctx.nft_ctx, move || {
+        Ok(try_s!(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")]

mm2src/coins/tx_history_storage/sql_tx_history_storage_v2.rs

@@ -376,12 +376,11 @@ pub struct SqliteTxHistoryStorage(Arc<Mutex<Connection>>);
 
 impl SqliteTxHistoryStorage {
     pub fn new(ctx: &MmArc) -> Result<Self, MmError<CreateTxHistoryStorageError>> {
-        let sqlite_connection =
-            ctx.sqlite_connection
-                .get()
-                .ok_or(MmError::new(CreateTxHistoryStorageError::Internal(
-                    "sqlite_connection is not initialized".to_owned(),
-                )))?;
+        let sqlite_connection = ctx
+            .sqlite_connection
+            .ok_or(MmError::new(CreateTxHistoryStorageError::Internal(
+                "sqlite_connection is not initialized".to_owned(),
+            )))?;
         Ok(SqliteTxHistoryStorage(sqlite_connection.clone()))
     }
 }

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.get().ok_or(BlockHeaderStorageError::Internal(
+        let sqlite_connection = ctx.sqlite_connection.ok_or(BlockHeaderStorageError::Internal(
             "sqlite_connection is not initialized".to_owned(),
         ))?;
         Ok(BlockHeaderStorage {
@@ -50,11 +50,8 @@ impl BlockHeaderStorage {
         use db_common::sqlite::rusqlite::Connection;
         use std::sync::{Arc, Mutex};
 
-        let conn = ctx
-            .sqlite_connection
-            .get()
-            .cloned()
-            .unwrap_or_else(|| Arc::new(Mutex::new(Connection::open_in_memory().unwrap())));
+        let conn = Arc::new(Mutex::new(Connection::open_in_memory().unwrap()));
+        let conn = ctx.sqlite_connection.clone_or(conn);
 
         Ok(BlockHeaderStorage {
             inner: Box::new(SqliteBlockHeadersStorage { ticker, conn }),

mm2src/coins/z_coin/storage/blockdb/blockdb_sql_storage.rs

@@ -49,9 +49,10 @@ 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_lock = conn.lock().unwrap();
-            run_optimization_pragmas(&conn_lock).map_to_mm(|err| ZcoinStorageError::DbError(err.to_string()))?;
-            conn_lock
+            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
                 .execute(
                     "CREATE TABLE IF NOT EXISTS compactblocks (
             height INTEGER PRIMARY KEY,
@@ -60,7 +61,6 @@ impl BlockDbImpl {
                     [],
                 )
                 .map_to_mm(|err| ZcoinStorageError::DbError(err.to_string()))?;
-            drop(conn_lock);
 
             Ok(Self { db: conn, ticker })
         })
@@ -73,12 +73,11 @@ impl BlockDbImpl {
         async_blocking(move || {
             let conn = ctx
                 .sqlite_connection
-                .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
+                .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
                 .execute(
                     "CREATE TABLE IF NOT EXISTS compactblocks (
             height INTEGER PRIMARY KEY,
@@ -87,7 +86,6 @@ impl BlockDbImpl {
                     [],
                 )
                 .map_to_mm(|err| ZcoinStorageError::DbError(err.to_string()))?;
-            drop(conn_lock);
 
             Ok(BlockDbImpl { db: conn, ticker })
         })

mm2src/crypto/src/crypto_ctx.rs

@@ -316,12 +316,10 @@ impl CryptoCtx {
         *ctx_field = Some(result.clone());
         drop(ctx_field);
 
-        ctx.rmd160
-            .set(rmd160)
-            .map_to_mm(|_| CryptoInitError::Internal("Already Initialized".to_string()))?;
+        ctx.rmd160.pin(rmd160).map_to_mm(CryptoInitError::Internal)?;
         ctx.shared_db_id
-            .set(shared_db_id)
-            .map_to_mm(|_| CryptoInitError::Internal("Already Initialized".to_string()))?;
+            .pin(shared_db_id)
+            .map_to_mm(CryptoInitError::Internal)?;
 
         info!("Public key hash: {rmd160}");
         info!("Shared Database ID: {shared_db_id}");

mm2src/mm2_bin_lib/src/lib.rs

@@ -41,7 +41,7 @@ fn mm2_status() -> MainStatus {
         Err(_) => return MainStatus::NoRpc,
     };
 
-    if *ctx.rpc_started.get().unwrap_or(&false) {
+    if ctx.rpc_started.copy_or(false) {
         MainStatus::RpcIsUp
     } else {
         MainStatus::NoRpc

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.get().ok_or(JsValue::from(Mm2RpcErr::NotRunning))?;
+    let wasm_rpc = ctx.wasm_rpc.ok_or(JsValue::from(Mm2RpcErr::NotRunning))?;
     let response: Mm2RpcResponse = wasm_rpc.request(request_json).await.into();
 
     serialize_to_js(&response).map_err(|e| {

mm2src/mm2_core/Cargo.toml

@@ -15,7 +15,6 @@ 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.12", default-features = false, features = ["identify"] }
@@ -32,13 +31,15 @@ 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" ] }
 timed-map = { version = "1.3", features = ["rustc-hash", "wasm"] }
 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"] }
 timed-map = { version = "1.3", features = ["rustc-hash"] }

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
-            .get()
+            .as_option()
             .or_mm_err(|| AccountStorageError::Internal("'MmCtx::sqlite_connection' is not initialized".to_owned()))?;
         Ok(SqliteAccountStorage {
             conn: Arc::clone(shared),

mm2src/mm2_main/src/lp_native_dex.rs

@@ -477,9 +477,7 @@ 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
-        .set(true)
-        .map_to_mm(|_| MmInitError::Internal("Already Initialized".to_string()))?;
+    ctx.initialized.pin(true).map_to_mm(MmInitError::Internal)?;
 
     // 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

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
-        .set(wallet_name.clone())
-        .map_to_mm(|_| WalletInitError::InternalError("Already Initialized".to_string()))?;
+        .pin(wallet_name.clone())
+        .map_to_mm(WalletInitError::InternalError)?;
     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.get().ok_or(GetWalletsError::Internal(
+    let activated_wallet = ctx.wallet_name.ok_or(GetWalletsError::Internal(
         "`wallet_name` not initialized yet!".to_string(),
     ))?;
 

mm2src/mm2_main/src/lp_wallet/mnemonics_storage.rs

@@ -47,7 +47,6 @@ 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(),
         ))?

mm2src/mm2_main/src/lp_wallet/mnemonics_wasm_db.rs

@@ -126,7 +126,6 @@ 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(),
         ))?

mm2src/mm2_main/src/mm2.rs

@@ -278,7 +278,7 @@ pub fn mm2_main(version: String, datetime: String) {
     }
 
     if first_arg == Some("--version") || first_arg == Some("-v") || first_arg == Some("version") {
-        println!("Komodo DeFi Framework: {version}");
+        println!("AtomicDEX API: {version}");
         return;
     }
 
@@ -292,7 +292,7 @@ pub fn mm2_main(version: String, datetime: String) {
         return;
     }
 
-    log!("Komodo DeFi Framework {} DT {}", version, datetime);
+    log!("AtomicDEX API {} DT {}", version, datetime);
 
     if let Err(err) = run_lp_main(first_arg, &|_| (), version, datetime) {
         log!("{}", err);

mm2src/mm2_main/src/ordermatch_tests.rs

@@ -1055,10 +1055,7 @@ fn test_cancel_by_single_coin() {
     let rx = prepare_for_cancel_by(&ctx);
 
     let connection = Connection::open_in_memory().unwrap();
-    let _ = ctx
-        .sqlite_connection
-        .set(Arc::new(Mutex::new(connection)))
-        .map_err(|_| "Already Initialized".to_string());
+    let _ = ctx.sqlite_connection.pin(Arc::new(Mutex::new(connection)));
 
     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(()))));
@@ -1077,10 +1074,7 @@ fn test_cancel_by_pair() {
     let rx = prepare_for_cancel_by(&ctx);
 
     let connection = Connection::open_in_memory().unwrap();
-    let _ = ctx
-        .sqlite_connection
-        .set(Arc::new(Mutex::new(connection)))
-        .map_err(|_| "Already Initialized".to_string());
+    let _ = ctx.sqlite_connection.pin(Arc::new(Mutex::new(connection)));
 
     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(()))));
@@ -1103,10 +1097,7 @@ fn test_cancel_by_all() {
     let rx = prepare_for_cancel_by(&ctx);
 
     let connection = Connection::open_in_memory().unwrap();
-    let _ = ctx
-        .sqlite_connection
-        .set(Arc::new(Mutex::new(connection)))
-        .map_err(|_| "Already Initialized".to_string());
+    let _ = ctx.sqlite_connection.pin(Arc::new(Mutex::new(connection)));
 
     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(()))));

mm2src/mm2_main/src/rpc.rs

@@ -410,7 +410,7 @@ pub extern "C" fn spawn_rpc(ctx_h: u32) {
                         $port,
                         now_sec()
                     );
-                    let _ = $ctx.rpc_started.set(true);
+                    let _ = $ctx.rpc_started.pin(true);
                     server
                 });
             }
@@ -479,7 +479,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.get().is_some() {
+    if ctx.wasm_rpc.is_some() {
         error!("RPC is initialized already");
         return;
     }
@@ -512,12 +512,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 ctx.wasm_rpc.set(request_tx).is_err() {
-        error!("'MmCtx::wasm_rpc' is initialized already");
+    if let Err(e) = ctx.wasm_rpc.pin(request_tx) {
+        error!("'MmCtx::wasm_rpc' is initialized already: {}", e);
         return;
     };
-    if ctx.rpc_started.set(true).is_err() {
-        error!("'MmCtx::rpc_started' is set already");
+    if let Err(e) = ctx.rpc_started.pin(true) {
+        error!("'MmCtx::rpc_started' is set already: {}", e);
         return;
     }
 

mm2src/mm2_main/tests/docker_tests/swap_watcher_tests.rs

@@ -3320,5 +3320,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!(watcher_reward.is_none());
+    assert!(matches!(watcher_reward, None));
 }