rust: remove gdk_electrum qualifier inside code

always use import, this is propedeutic to re-organization

Author: RCasatta

subprojects/gdk_rust/src/lib.rs

@@ -27,8 +27,9 @@ use gdk_common::model::{
 };
 
 use crate::error::Error;
-use gdk_electrum::pset::{ExtractTxParam, FromTxParam, MergeTxParam};
-use gdk_electrum::ElectrumSession;
+use gdk_electrum::error::Error as ElectrumError;
+use gdk_electrum::pset::{self, ExtractTxParam, FromTxParam, MergeTxParam};
+use gdk_electrum::{determine_electrum_url_from_net, headers, ElectrumSession};
 use log::{LevelFilter, Metadata, Record};
 use serde::Serialize;
 use std::str::FromStr;
@@ -134,8 +135,7 @@ fn create_session(network: &Value) -> Result<GdkSession, Value> {
     match network["server_type"].as_str() {
         // Some("rpc") => GDKRUST_session::Rpc( GDKRPC_session::create_session(parsed_network.unwrap()).unwrap() ),
         Some("electrum") => {
-            let url = gdk_electrum::determine_electrum_url_from_net(&parsed_network)
-                .map_err(|x| json!(x))?;
+            let url = determine_electrum_url_from_net(&parsed_network).map_err(|x| json!(x))?;
 
             let session = ElectrumSession::create_session(parsed_network, db_root, proxy, url);
             let backend = GdkBackend::Electrum(session);
@@ -245,7 +245,7 @@ pub extern "C" fn GDKRUST_call_session(
         Ok(ref val) => (val.to_string(), GA_OK),
         Err(ref e) => {
             let ret_val = match e {
-                Error::Electrum(gdk_electrum::error::Error::InvalidPin) => GA_NOT_AUTHORIZED,
+                Error::Electrum(ElectrumError::InvalidPin) => GA_NOT_AUTHORIZED,
                 _ => GA_ERROR,
             };
             let json_error = build_error(&method, e);
@@ -527,23 +527,23 @@ fn handle_call(method: &str, input: &str) -> Result<String, Error> {
     match method {
         "psbt_extract_tx" => {
             let param: ExtractTxParam = serde_json::from_str(input)?;
-            Ok(to_string(&gdk_electrum::pset::extract_tx(&param)?))
+            Ok(to_string(&pset::extract_tx(&param)?))
         }
         "psbt_from_tx" => {
             let param: FromTxParam = serde_json::from_str(input)?;
-            Ok(to_string(&gdk_electrum::pset::from_tx(&param)?))
+            Ok(to_string(&pset::from_tx(&param)?))
         }
         "psbt_merge_tx" => {
             let param: MergeTxParam = serde_json::from_str(input)?;
-            Ok(to_string(&gdk_electrum::pset::merge_tx(&param)?))
+            Ok(to_string(&pset::merge_tx(&param)?))
         }
         "spv_verify_tx" => {
             let param: SPVVerifyTxParams = serde_json::from_str(input)?;
-            Ok(to_string(&gdk_electrum::headers::spv_verify_tx(&param)?.as_i32()))
+            Ok(to_string(&headers::spv_verify_tx(&param)?.as_i32()))
         }
         "spv_download_headers" => {
             let param: SPVDownloadHeadersParams = serde_json::from_str(input)?;
-            Ok(to_string(&gdk_electrum::headers::download_headers(&param)?))
+            Ok(to_string(&headers::download_headers(&param)?))
         }
         _ => Err(Error::MethodNotFound {
             method: method.to_string(),

subprojects/gdk_rust/tests/integration.rs

@@ -10,7 +10,9 @@ use gdk_common::Network;
 use gdk_electrum::error::Error;
 use gdk_electrum::headers::bitcoin::HeadersChain;
 use gdk_electrum::interface::ElectrumUrl;
-use gdk_electrum::{determine_electrum_url_from_net, spv, ElectrumSession, Notification, State};
+use gdk_electrum::{
+    determine_electrum_url_from_net, headers, spv, ElectrumSession, Notification, State,
+};
 
 use log::info;
 use serde_json::{json, Value};
@@ -1364,7 +1366,7 @@ fn test_spv_timeout() {
         },
         headers_to_download: Some(1),
     };
-    let _ = gdk_electrum::headers::download_headers(&param_download);
+    let _ = headers::download_headers(&param_download);
 
     assert!(now.elapsed().as_secs() <= 5, "more than timeout time passed");
 }

subprojects/gdk_rust/tests/test_session.rs

@@ -14,10 +14,10 @@ use gdk_common::wally::{asset_blinding_key_from_seed, MasterBlindingKey};
 use gdk_common::Network;
 use gdk_common::{ElementsNetwork, NetworkId};
 use gdk_electrum::error::Error;
-use gdk_electrum::Notification;
 use gdk_electrum::{
     determine_electrum_url_from_net, keys_from_mnemonic, spv, ElectrumSession, State,
 };
+use gdk_electrum::{headers, Notification};
 use log::{info, warn, Metadata, Record};
 use serde_json::{json, Value};
 use std::collections::HashSet;
@@ -968,12 +968,12 @@ impl TestSession {
         thread::spawn(move || {
             let mut synced = 0;
             while synced < tip {
-                let result = gdk_electrum::headers::download_headers(&param_download).unwrap();
+                let result = headers::download_headers(&param_download).unwrap();
                 synced = result.height;
             }
         });
         loop {
-            match gdk_electrum::headers::spv_verify_tx(&param) {
+            match headers::spv_verify_tx(&param) {
                 Ok(SPVVerifyTxResult::InProgress) => {
                     thread::sleep(Duration::from_millis(100));
                 }
@@ -983,10 +983,7 @@ impl TestSession {
         }
 
         // second should verify immediately, (and also hit cache)
-        assert!(matches!(
-            gdk_electrum::headers::spv_verify_tx(&param),
-            Ok(SPVVerifyTxResult::Verified)
-        ));
+        assert!(matches!(headers::spv_verify_tx(&param), Ok(SPVVerifyTxResult::Verified)));
     }
 
     pub fn refresh_assets(