fix(cli): make mm2-libp2p optional in mm2_net for adex-cli

mm2src/coins/eth/eth_wasm_tests.rs

@@ -1,8 +1,10 @@
 use super::*;
 use crate::lp_coininit;
+use crypto::privkey::key_pair_from_seed;
 use crypto::CryptoCtx;
 use mm2_core::mm_ctx::MmCtxBuilder;
 use mm2_test_helpers::for_tests::{ETH_DEV_NODE, ETH_DEV_SWAP_CONTRACT};
+use mm2_test_helpers::get_passphrase;
 use wasm_bindgen_test::*;
 use web_sys::console;
 
@@ -16,10 +18,9 @@ fn pass() {
 
 #[wasm_bindgen_test]
 async fn test_send() {
-    let key_pair = KeyPair::from_secret_slice(
-        &hex::decode("809465b17d0a4ddb3e4c69e8f23c2cabad868f51f8bed5c765ad1d6516c3306f").unwrap(),
-    )
-    .unwrap();
+    let seed = get_passphrase!(".env.client", "ALICE_PASSPHRASE").unwrap();
+    let keypair = key_pair_from_seed(&seed).unwrap();
+    let key_pair = KeyPair::from_secret_slice(keypair.private_ref()).unwrap();
     let transport = Web3Transport::single_node(ETH_DEV_NODE, false);
     let web3 = Web3::new(transport);
     let ctx = MmCtxBuilder::new().into_mm_arc();

mm2src/coins/eth/web3_transport/http_transport.rs

@@ -23,9 +23,16 @@ pub struct AuthPayload<'a> {
 /// Parse bytes RPC response into `Result`.
 /// Implementation copied from Web3 HTTP transport
 #[cfg(not(target_arch = "wasm32"))]
-fn single_response<T: Deref<Target = [u8]>>(response: T, rpc_url: &str) -> Result<Json, Error> {
-    let response =
-        serde_json::from_slice(&response).map_err(|e| Error::InvalidResponse(format!("{}: {}", rpc_url, e)))?;
+fn single_response<T>(response: T, rpc_url: &str) -> Result<Json, Error>
+where
+    T: Deref<Target = [u8]> + std::fmt::Debug,
+{
+    let response = serde_json::from_slice(&response).map_err(|e| {
+        Error::InvalidResponse(format!(
+            "url: {}, Error deserializing response: {}, raw response: {:?}",
+            rpc_url, e, response
+        ))
+    })?;
 
     match response {
         Response::Single(output) => to_result_from_output(output),
@@ -325,7 +332,12 @@ async fn send_request_once(
     // account for incoming traffic
     event_handlers.on_incoming_response(response_str.as_bytes());
 
-    let response: Response = serde_json::from_str(&response_str).map_err(|e| Error::InvalidResponse(e.to_string()))?;
+    let response: Response = serde_json::from_str(&response_str).map_err(|e| {
+        Error::InvalidResponse(format!(
+            "url: {}, Error deserializing response: {}, raw response: {:?}",
+            uri, e, response_str
+        ))
+    })?;
     match response {
         Response::Single(output) => to_result_from_output(output),
         Response::Batch(_) => Err(Error::InvalidResponse("Expected single, got batch.".to_owned())),

mm2src/coins/utxo/utxo_common_tests.rs

@@ -15,7 +15,6 @@ use common::PagingOptionsEnum;
 use crypto::privkey::key_pair_from_seed;
 use itertools::Itertools;
 use mm2_test_helpers::for_tests::mm_ctx_with_custom_db;
-use std::convert::TryFrom;
 use std::num::NonZeroUsize;
 use std::time::Duration;
 
@@ -205,16 +204,19 @@ pub(super) async fn test_electrum_display_balances(rpc_client: &ElectrumClient)
     let expected: Vec<(Address, BigDecimal)> = vec![
         (
             "RG278CfeNPFtNztFZQir8cgdWexVhViYVy".into(),
-            BigDecimal::try_from(5.77699).unwrap(),
+            BigDecimal::from_str("5.77699").unwrap(),
+        ),
+        (
+            "RYPz6Lr4muj4gcFzpMdv3ks1NCGn3mkDPN".into(),
+            BigDecimal::from_str("3.33").unwrap(),
         ),
-        ("RYPz6Lr4muj4gcFzpMdv3ks1NCGn3mkDPN".into(), BigDecimal::from(0)),
         (
             "RJeDDtDRtKUoL8BCKdH7TNCHqUKr7kQRsi".into(),
-            BigDecimal::try_from(0.77699).unwrap(),
+            BigDecimal::from_str("0.77699").unwrap(),
         ),
         (
             "RQHn9VPHBqNjYwyKfJbZCiaxVrWPKGQjeF".into(),
-            BigDecimal::try_from(16.55398).unwrap(),
+            BigDecimal::from_str("16.55398").unwrap(),
         ),
     ];
     assert_eq!(actual, expected);

mm2src/coins/utxo/utxo_wasm_tests.rs

@@ -5,6 +5,7 @@ use super::*;
 use crate::utxo::utxo_common_tests;
 use crate::{IguanaPrivKey, PrivKeyBuildPolicy};
 use mm2_core::mm_ctx::MmCtxBuilder;
+use mm2_test_helpers::for_tests::DOC_ELECTRUM_ADDRS;
 use serialization::deserialize;
 use wasm_bindgen_test::*;
 
@@ -45,9 +46,9 @@ pub async fn electrum_client_for_test(servers: &[&str]) -> ElectrumClient {
 
 #[wasm_bindgen_test]
 async fn test_electrum_rpc_client() {
-    let client = electrum_client_for_test(&["electrum1.cipig.net:30017", "electrum2.cipig.net:30017"]).await;
+    let client = electrum_client_for_test(DOC_ELECTRUM_ADDRS).await;
 
-    let tx_hash: H256Json = hex::decode("0a0fda88364b960000f445351fe7678317a1e0c80584de0413377ede00ba696f")
+    let tx_hash: H256Json = hex::decode("a3ebedbe20f82e43708f276152cf7dfb03a6050921c8f266e48c00ab66e891fb")
         .unwrap()
         .as_slice()
         .into();
@@ -57,13 +58,13 @@ async fn test_electrum_rpc_client() {
         .await
         .expect("!get_verbose_transaction");
     let actual: UtxoTx = deserialize(verbose_tx.hex.as_slice()).unwrap();
-    let expected = UtxoTx::from("0400008085202f8902358549fe3cf9a66bf61fb57bca1b3b49434a148a4dc29450b5eefe583f2f9ecf000000006a4730440220112aa3737672f8aa16a58426f5e7656ad13d21a219390c7a0b2e266ee6b216a8022008e9f9e94db91f069f831b0d40b7f75938122cddceaa25197146dfb00fe82599012102031d4256c4bc9f99ac88bf3dba21773132281f65f9bf23a59928bce08961e2f3ffffffff358549fe3cf9a66bf61fb57bca1b3b49434a148a4dc29450b5eefe583f2f9ecf010000006b483045022100d054464799246254b09f96333bf52537938abe31c24bacf41c9ef600b28155950220527ec33c4a5bef79dcabf97e38aa240fecdd14c96f698560b2f10ec2abc2e992012102031d4256c4bc9f99ac88bf3dba21773132281f65f9bf23a59928bce08961e2f3ffffffff0240420f00000000001976a91405aab5342166f8594baf17a7d9bef5d56744332788ac66418f00000000001976a91405aab5342166f8594baf17a7d9bef5d56744332788ac0e2aa85f000000000000000000000000000000");
+    let expected = UtxoTx::from("0400008085202f8901e15182af2c252bcfbd58884f3bdbd4d85ed036e53cfe2fd1f904ecfea10cb9f2010000006b483045022100d2435e0c9211114271ac452dc47fd08d3d2dc4bdd484d5750ee6bbda41056d520220408bfb236b7028b6fde0e59a1b6522949131a611584cce36c3df1e934c1748630121022d7424c741213a2b9b49aebdaa10e84419e642a8db0a09e359a3d4c850834846ffffffff02a09ba104000000001976a914054407d1a2224268037cfc7ca3bc438d082bedf488acdd28ce9157ba11001976a914046922483fab8ca76b23e55e9d338605e2dbab6088ac03d63665000000000000000000000000000000");
     assert_eq!(actual, expected);
 }
 
 #[wasm_bindgen_test]
 async fn test_electrum_display_balances() {
-    let rpc_client = electrum_client_for_test(&["electrum1.cipig.net:30017", "electrum2.cipig.net:30017"]).await;
+    let rpc_client = electrum_client_for_test(DOC_ELECTRUM_ADDRS).await;
     utxo_common_tests::test_electrum_display_balances(&rpc_client).await;
 }
 

mm2src/mm2_main/Cargo.toml

@@ -62,7 +62,7 @@ mm2_gui_storage = { path = "../mm2_gui_storage" }
 mm2_io = { path = "../mm2_io" }
 mm2-libp2p = { path = "../mm2_p2p", package = "mm2_p2p" }
 mm2_metrics = { path = "../mm2_metrics" }
-mm2_net = { path = "../mm2_net" }
+mm2_net = { path = "../mm2_net", features = ["event-stream", "p2p"] }
 mm2_number = { path = "../mm2_number" }
 mm2_rpc = { path = "../mm2_rpc", features = ["rpc_facilities"]}
 mm2_state_machine = { path = "../mm2_state_machine" }

mm2src/mm2_main/src/wasm_tests.rs

@@ -4,7 +4,7 @@ use common::log::wasm_log::register_wasm_log;
 use crypto::StandardHDCoinAddress;
 use mm2_core::mm_ctx::MmArc;
 use mm2_rpc::data::legacy::OrderbookResponse;
-use mm2_test_helpers::electrums::{morty_electrums, rick_electrums};
+use mm2_test_helpers::electrums::{doc_electrums, marty_electrums};
 use mm2_test_helpers::for_tests::{check_recent_swaps, enable_electrum_json, morty_conf, rick_conf, start_swaps,
                                   test_qrc20_history_impl, wait_for_swaps_finish_and_check_status, MarketMakerIt,
                                   Mm2InitPrivKeyPolicy, Mm2TestConf, Mm2TestConfForSwap, MORTY, RICK};
@@ -48,17 +48,17 @@ async fn test_mm2_stops_impl(
     Timer::sleep(2.).await;
 
     // Enable coins on Bob side. Print the replies in case we need the address.
-    let rc = enable_electrum_json(&mm_bob, RICK, true, rick_electrums(), None).await;
+    let rc = enable_electrum_json(&mm_bob, RICK, true, doc_electrums(), None).await;
     log!("enable RICK (bob): {:?}", rc);
 
-    let rc = enable_electrum_json(&mm_bob, MORTY, true, morty_electrums(), None).await;
+    let rc = enable_electrum_json(&mm_bob, MORTY, true, marty_electrums(), None).await;
     log!("enable MORTY (bob): {:?}", rc);
 
     // Enable coins on Alice side. Print the replies in case we need the address.
-    let rc = enable_electrum_json(&mm_alice, RICK, true, rick_electrums(), None).await;
+    let rc = enable_electrum_json(&mm_alice, RICK, true, doc_electrums(), None).await;
     log!("enable RICK (bob): {:?}", rc);
 
-    let rc = enable_electrum_json(&mm_alice, MORTY, true, morty_electrums(), None).await;
+    let rc = enable_electrum_json(&mm_alice, MORTY, true, marty_electrums(), None).await;
     log!("enable MORTY (bob): {:?}", rc);
 
     start_swaps(&mut mm_bob, &mut mm_alice, pairs, maker_price, taker_price, volume).await;
@@ -112,17 +112,17 @@ async fn trade_base_rel_electrum(
     let (_alice_dump_log, _alice_dump_dashboard) = mm_alice.mm_dump();
 
     // Enable coins on Bob side. Print the replies in case we need the address.
-    let rc = enable_electrum_json(&mm_bob, RICK, true, rick_electrums(), bob_path_to_address.clone()).await;
+    let rc = enable_electrum_json(&mm_bob, RICK, true, doc_electrums(), bob_path_to_address.clone()).await;
     log!("enable RICK (bob): {:?}", rc);
 
-    let rc = enable_electrum_json(&mm_bob, MORTY, true, morty_electrums(), bob_path_to_address).await;
+    let rc = enable_electrum_json(&mm_bob, MORTY, true, marty_electrums(), bob_path_to_address).await;
     log!("enable MORTY (bob): {:?}", rc);
 
     // Enable coins on Alice side. Print the replies in case we need the address.
-    let rc = enable_electrum_json(&mm_alice, RICK, true, rick_electrums(), alice_path_to_address.clone()).await;
+    let rc = enable_electrum_json(&mm_alice, RICK, true, doc_electrums(), alice_path_to_address.clone()).await;
     log!("enable RICK (bob): {:?}", rc);
 
-    let rc = enable_electrum_json(&mm_alice, MORTY, true, morty_electrums(), alice_path_to_address).await;
+    let rc = enable_electrum_json(&mm_alice, MORTY, true, marty_electrums(), alice_path_to_address).await;
     log!("enable MORTY (bob): {:?}", rc);
 
     let uuids = start_swaps(&mut mm_bob, &mut mm_alice, pairs, maker_price, taker_price, volume).await;

mm2src/mm2_main/tests/integration_tests_common/mod.rs

@@ -5,7 +5,7 @@ use crypto::privkey::key_pair_from_seed;
 use crypto::StandardHDCoinAddress;
 use mm2_main::mm2::{lp_main, LpMainParams};
 use mm2_rpc::data::legacy::CoinInitResponse;
-use mm2_test_helpers::electrums::{morty_electrums, rick_electrums};
+use mm2_test_helpers::electrums::{doc_electrums, marty_electrums};
 use mm2_test_helpers::for_tests::{enable_native as enable_native_impl, init_utxo_electrum, init_utxo_status,
                                   init_z_coin_light, init_z_coin_status, MarketMakerIt};
 use mm2_test_helpers::structs::{InitTaskResult, InitUtxoStatus, InitZcoinStatus, RpcV2Response,
@@ -74,11 +74,11 @@ pub async fn enable_coins_rick_morty_electrum(mm: &MarketMakerIt) -> HashMap<&'s
     let mut replies = HashMap::new();
     replies.insert(
         "RICK",
-        enable_electrum_json(mm, "RICK", false, rick_electrums(), None).await,
+        enable_electrum_json(mm, "RICK", false, doc_electrums(), None).await,
     );
     replies.insert(
         "MORTY",
-        enable_electrum_json(mm, "MORTY", false, morty_electrums(), None).await,
+        enable_electrum_json(mm, "MORTY", false, marty_electrums(), None).await,
     );
     replies
 }
@@ -145,11 +145,11 @@ pub async fn enable_coins_eth_electrum(
     let mut replies = HashMap::new();
     replies.insert(
         "RICK",
-        enable_electrum_json(mm, "RICK", false, rick_electrums(), path_to_address.clone()).await,
+        enable_electrum_json(mm, "RICK", false, doc_electrums(), path_to_address.clone()).await,
     );
     replies.insert(
         "MORTY",
-        enable_electrum_json(mm, "MORTY", false, morty_electrums(), path_to_address.clone()).await,
+        enable_electrum_json(mm, "MORTY", false, marty_electrums(), path_to_address.clone()).await,
     );
     replies.insert("ETH", enable_native(mm, "ETH", eth_urls, path_to_address.clone()).await);
     replies.insert("JST", enable_native(mm, "JST", eth_urls, path_to_address).await);

mm2src/mm2_main/tests/mm2_tests/best_orders_tests.rs

@@ -3,10 +3,9 @@ use common::{block_on, log};
 use http::StatusCode;
 use mm2_number::BigDecimal;
 use mm2_rpc::data::legacy::CoinInitResponse;
-use mm2_test_helpers::for_tests::ETH_DEV_NODES;
 use mm2_test_helpers::for_tests::{best_orders_v2, best_orders_v2_by_number, eth_jst_testnet_conf, eth_testnet_conf,
                                   get_passphrase, morty_conf, rick_conf, tbtc_conf, tbtc_segwit_conf, MarketMakerIt,
-                                  Mm2TestConf, RICK_ELECTRUM_ADDRS, TBTC_ELECTRUMS};
+                                  Mm2TestConf, DOC_ELECTRUM_ADDRS, ETH_DEV_NODES, TBTC_ELECTRUMS};
 use mm2_test_helpers::structs::{BestOrdersResponse, SetPriceResponse};
 use serde_json::{self as json, json};
 use std::collections::BTreeSet;
@@ -837,22 +836,8 @@ fn test_best_orders_address_and_confirmations() {
     let enable_tbtc_res: CoinInitResponse = json::from_str(&electrum.1).unwrap();
     let tbtc_segwit_address = enable_tbtc_res.address;
 
-    let electrum = block_on(mm_bob.rpc(&json!({
-        "userpass": "pass",
-        "method": "electrum",
-        "coin": "RICK",
-        "servers": [{"url":"electrum1.cipig.net:10017"},{"url":"electrum2.cipig.net:10017"},{"url":"electrum3.cipig.net:10017"}],
-        "mm2": 1,
-    }))).unwrap();
-    assert_eq!(
-        electrum.0,
-        StatusCode::OK,
-        "RPC «electrum» failed with {} {}",
-        electrum.0,
-        electrum.1
-    );
-    log!("enable RICK: {:?}", electrum);
-    let enable_rick_res: CoinInitResponse = json::from_str(&electrum.1).unwrap();
+    let enable_rick_res = block_on(enable_electrum(&mm_bob, "RICK", false, DOC_ELECTRUM_ADDRS, None));
+    log!("enable RICK: {:?}", enable_rick_res);
     let rick_address = enable_rick_res.address;
 
     // issue sell request on Bob side by setting base/rel price
@@ -999,7 +984,7 @@ fn best_orders_must_return_duplicate_for_orderbook_tickers() {
     let t_btc_bob = block_on(enable_electrum(&mm_bob, "tBTC", false, TBTC_ELECTRUMS, None));
     log!("Bob enable tBTC: {:?}", t_btc_bob);
 
-    let rick_bob = block_on(enable_electrum(&mm_bob, "RICK", false, RICK_ELECTRUM_ADDRS, None));
+    let rick_bob = block_on(enable_electrum(&mm_bob, "RICK", false, DOC_ELECTRUM_ADDRS, None));
     log!("Bob enable RICK: {:?}", rick_bob);
 
     // issue sell request on Bob side by setting base/rel price
@@ -1116,10 +1101,9 @@ fn best_orders_must_return_duplicate_for_orderbook_tickers() {
 #[cfg(feature = "zhtlc-native-tests")]
 fn zhtlc_best_orders() {
     use super::enable_z_coin;
+    use mm2_test_helpers::electrums::doc_electrums;
     use mm2_test_helpers::for_tests::zombie_conf;
 
-    use mm2_test_helpers::electrums::rick_electrums;
-
     let bob_passphrase = get_passphrase(&".env.seed", "BOB_PASSPHRASE").unwrap();
     let alice_passphrase = get_passphrase(&".env.client", "ALICE_PASSPHRASE").unwrap();
 
@@ -1150,7 +1134,7 @@ fn zhtlc_best_orders() {
     log!("bob_zombie_cache_path {}", bob_zombie_cache_path.display());
     std::fs::copy("./mm2src/coins/for_tests/ZOMBIE_CACHE.db", bob_zombie_cache_path).unwrap();
 
-    block_on(enable_electrum_json(&mm_bob, "RICK", false, rick_electrums(), None));
+    block_on(enable_electrum_json(&mm_bob, "RICK", false, doc_electrums(), None));
     block_on(enable_z_coin(&mm_bob, "ZOMBIE"));
 
     let set_price_json = json!({