chore(release): v1.0.7-beta

docs/GIT_FLOW_AND_WORKING_PROCESS.md

@@ -31,5 +31,5 @@ Cons:
 [@artemii235](https://github.com/artemii235)
 [@sergeyboyko0791](https://github.com/sergeyboyko0791)
 [@shamardy](https://github.com/shamardy)
-[@ozkanonur](https://github.com/ozkanonur)
+[@onur-ozkan](https://github.com/onur-ozkan)
 

mm2src/adex_cli/Cargo.toml

@@ -15,6 +15,8 @@ derive_more = "0.99"
 directories = "5.0"
 env_logger = "0.7.1"
 http = "0.2"
+hyper = { version = "0.14.26", features = ["client", "http2", "tcp"] }
+hyper-rustls = "^0.23.0"
 gstuff = { version = "=0.7.4" , features = [ "nightly" ]}
 inquire = "0.6"
 itertools = "0.10"
@@ -23,14 +25,14 @@ mm2_net = { path = "../mm2_net" }
 mm2_number = { path = "../mm2_number" }
 mm2_rpc = { path = "../mm2_rpc"}
 passwords = "3.1"
+rpc = { path = "../mm2_bitcoin/rpc" }
+rustls = { version = "^0.20.4", features = [ "dangerous_configuration" ] }
 serde = "1.0"
 serde_json = { version = "1", features = ["preserve_order", "raw_value"] }
 sysinfo = "0.28"
 tiny-bip39 = "0.8.0"
 tokio = { version = "1.20", features = [ "macros" ] }
 uuid = { version = "1.2.2", features = ["fast-rng", "serde", "v4"] }
-rpc = { path = "../mm2_bitcoin/rpc" }
 
 [target.'cfg(windows)'.dependencies]
 winapi = { version = "0.3.3", features = ["processthreadsapi", "winnt"] }
-

mm2src/adex_cli/src/activation_scheme_db/activation_scheme_impl.rs

@@ -1,19 +1,29 @@
 use anyhow::{anyhow, bail, Result};
-use log::{debug, error};
 use serde_json::Value as Json;
 use std::collections::HashMap;
 
+use common::log::{debug, error};
+
 use super::init_activation_scheme::get_activation_scheme_path;
 use crate::helpers::read_json_file;
 use crate::logging::{error_anyhow, error_bail};
+use crate::rpc_data::ActivationRequest;
 
 #[derive(Default)]
 pub(crate) struct ActivationScheme {
     scheme: HashMap<String, Json>,
 }
 
 impl ActivationScheme {
-    pub(crate) fn get_activation_method(&self, coin: &str) -> Option<&Json> { self.scheme.get(coin) }
+    pub(crate) fn get_activation_method(&self, coin: &str) -> Result<ActivationRequest> {
+        let method_json = self
+            .scheme
+            .get(coin)
+            .ok_or_else(|| error_anyhow!("Coin is not in activation scheme data: {}", coin))?;
+        let method: ActivationRequest = serde_json::from_value(method_json.clone())
+            .map_err(|error| error_anyhow!("Failed to deserialize json data: {:?}, error: {}", method_json, error))?;
+        Ok(method)
+    }
 
     fn init(&mut self) -> Result<()> {
         let mut scheme_source: Vec<Json> = Self::load_json_file()?;

mm2src/adex_cli/src/adex_config.rs

@@ -9,6 +9,7 @@ use std::path::{Path, PathBuf};
 
 use crate::adex_proc::SmartFractPrecision;
 use crate::helpers::rewrite_json_file;
+#[cfg(unix)] use crate::helpers::set_file_permissions;
 use crate::logging::{error_anyhow, warn_bail};
 
 const PROJECT_QUALIFIER: &str = "com";
@@ -22,6 +23,8 @@ const VOLUME_PRECISION_MIN: usize = 2;
 const VOLUME_PRECISION_MAX: usize = 5;
 const VOLUME_PRECISION: SmartFractPrecision = (VOLUME_PRECISION_MIN, VOLUME_PRECISION_MAX);
 const PRICE_PRECISION: SmartFractPrecision = (PRICE_PRECISION_MIN, PRICE_PRECISION_MAX);
+#[cfg(unix)]
+const CFG_FILE_PERM_MODE: u32 = 0o660;
 
 pub(super) fn get_config() {
     let Ok(adex_cfg) = AdexConfigImpl::from_config_path() else { return; };
@@ -151,7 +154,12 @@ impl AdexConfigImpl {
         let adex_path_str = cfg_path
             .to_str()
             .ok_or_else(|| error_anyhow!("Failed to get cfg_path as str"))?;
-        rewrite_json_file(self, adex_path_str)
+        rewrite_json_file(self, adex_path_str)?;
+        #[cfg(unix)]
+        {
+            set_file_permissions(adex_path_str, CFG_FILE_PERM_MODE)?;
+        }
+        Ok(())
     }
 
     fn set_rpc_password(&mut self, rpc_password: String) { self.rpc_password.replace(rpc_password); }

mm2src/adex_cli/src/adex_proc/adex_proc_impl.rs

@@ -10,7 +10,7 @@ use super::OrderbookConfig;
 use crate::activation_scheme_db::get_activation_scheme;
 use crate::adex_config::AdexConfig;
 use crate::transport::Transport;
-use crate::{error_anyhow, error_bail, warn_anyhow, warn_bail};
+use crate::{error_anyhow, error_bail, warn_anyhow};
 
 pub(crate) struct AdexProc<'trp, 'hand, 'cfg, T: Transport, H: ResponseHandler, C: AdexConfig + ?Sized> {
     pub(crate) transport: Option<&'trp T>,
@@ -37,9 +37,7 @@ impl<T: Transport, P: ResponseHandler, C: AdexConfig + 'static> AdexProc<'_, '_,
         info!("Enabling asset: {asset}");
 
         let activation_scheme = get_activation_scheme()?;
-        let Some(activation_method) = activation_scheme.get_activation_method(asset) else {
-            warn_bail!("Asset is not known: {asset}")
-        };
+        let activation_method = activation_scheme.get_activation_method(asset)?;
 
         let enable = Command::builder()
             .flatten_data(activation_method)

mm2src/adex_cli/src/helpers.rs

@@ -4,6 +4,7 @@ use serde::{Deserialize, Serialize};
 use std::fs;
 use std::io::Write;
 use std::ops::Deref;
+#[cfg(unix)] use std::os::unix::fs::PermissionsExt;
 use std::path::Path;
 
 use crate::error_anyhow;
@@ -22,6 +23,15 @@ where
     writer
         .write(&data)
         .map_err(|error| error_anyhow!("Failed to write data into {file}: {error}"))?;
+
+    Ok(())
+}
+
+#[cfg(unix)]
+pub(crate) fn set_file_permissions(file: &str, unix_mode: u32) -> Result<()> {
+    let mut perms = fs::metadata(file)?.permissions();
+    perms.set_mode(unix_mode);
+    fs::set_permissions(file, perms)?;
     Ok(())
 }
 

mm2src/adex_cli/src/main.rs

@@ -5,6 +5,7 @@
 #[cfg(not(target_arch = "wasm32"))] mod cli;
 #[cfg(not(target_arch = "wasm32"))] mod helpers;
 mod logging;
+#[cfg(not(target_arch = "wasm32"))] mod rpc_data;
 #[cfg(not(target_arch = "wasm32"))] mod scenarios;
 #[cfg(all(not(target_arch = "wasm32"), test))] mod tests;
 #[cfg(not(target_arch = "wasm32"))] mod transport;

mm2src/adex_cli/src/rpc_data.rs

@@ -0,0 +1,71 @@
+//! Contains rpc data layer structures that are not ready to become a part of the mm2_rpc::data module
+//!
+//! *Note: it's expected that the following data types will be moved to mm2_rpc::data when mm2 is refactored to be able to handle them*
+//!
+
+use mm2_rpc::data::legacy::{ElectrumProtocol, GasStationPricePolicy, UtxoMergeParams};
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(tag = "method", rename_all = "lowercase")]
+pub(crate) enum ActivationRequest {
+    Enable(EnableRequest),
+    Electrum(ElectrumRequest),
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+pub(crate) struct EnableRequest {
+    coin: String,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    urls: Vec<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    swap_contract_address: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    fallback_swap_contract: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    gas_station_url: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    gas_station_decimals: Option<u8>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    gas_station_policy: Option<GasStationPricePolicy>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    mm2: Option<u8>,
+    #[serde(default)]
+    tx_history: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    required_confirmations: Option<u64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    requires_notarization: Option<bool>,
+    #[serde(default)]
+    contract_supports_watchers: Option<bool>,
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+pub(crate) struct ElectrumRequest {
+    coin: String,
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    pub(super) servers: Vec<Server>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    mm2: Option<u8>,
+    #[serde(default)]
+    tx_history: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    required_confirmations: Option<u64>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    requires_notarization: Option<bool>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    swap_contract_address: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    fallback_swap_contract: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    utxo_merge_params: Option<UtxoMergeParams>,
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+pub(super) struct Server {
+    url: String,
+    #[serde(default)]
+    protocol: ElectrumProtocol,
+    #[serde(default)]
+    disable_cert_verification: bool,
+}

mm2src/adex_cli/src/tests/mod.rs

@@ -7,6 +7,7 @@ use crate::activation_scheme_db::{get_activation_scheme, get_activation_scheme_p
 use crate::adex_config::AdexConfigImpl;
 use crate::adex_proc::ResponseHandlerImpl;
 use crate::cli::Cli;
+use crate::rpc_data::ActivationRequest;
 
 const FAKE_SERVER_COOLDOWN_TIMEOUT_MS: u64 = 10;
 const FAKE_SERVER_WARMUP_TIMEOUT_MS: u64 = 100;
@@ -146,10 +147,10 @@ async fn test_activation_scheme() {
     init_activation_scheme().await.unwrap();
     let scheme = get_activation_scheme().unwrap();
     let kmd_scheme = scheme.get_activation_method("KMD");
-    assert!(kmd_scheme.is_some());
-    let kmd_scheme = kmd_scheme.unwrap();
-    assert_eq!(kmd_scheme.get("method").unwrap().as_str().unwrap(), "electrum");
-    assert_ne!(kmd_scheme.get("servers").unwrap().as_array().unwrap().iter().count(), 0);
+    let Ok(ActivationRequest::Electrum(electrum)) = kmd_scheme else {
+         panic!("Failed to get electrum scheme")
+    };
+    assert_ne!(electrum.servers.len(), 0);
 }
 
 #[tokio::test]