diff --git a/mm2src/coins/lightning/ln_events.rs b/mm2src/coins/lightning/ln_events.rs
index 3a761cc2b3..d6c78f9ad9 100644
--- a/mm2src/coins/lightning/ln_events.rs
+++ b/mm2src/coins/lightning/ln_events.rs
@@ -2,7 +2,6 @@ use super::*;
 use crate::lightning::ln_db::{DBChannelDetails, HTLCStatus, LightningDB, PaymentType};
 use crate::lightning::ln_errors::{SaveChannelClosingError, SaveChannelClosingResult};
 use crate::lightning::ln_sql::SqliteLightningDB;
-use crate::utxo::UtxoCommonOps;
 use bitcoin::blockdata::script::Script;
 use bitcoin::blockdata::transaction::Transaction;
 use bitcoin::consensus::encode::serialize_hex;
@@ -209,25 +208,15 @@ async fn sign_funding_transaction(
     };
     unsigned.outputs[0].script_pubkey = output_script_pubkey.to_bytes().into();
 
-    let my_address = coin
-        .as_ref()
-        .derivation_method
-        .single_addr_or_err()
-        .await
-        .map_err(|e| SignFundingTransactionError::Internal(e.to_string()))?;
     let key_pair = coin
         .as_ref()
         .priv_key_policy
         .activated_key_or_err()
         .map_err(|e| SignFundingTransactionError::Internal(e.to_string()))?;
 
-    let prev_script = coin
-        .script_for_address(&my_address)
-        .map_err(|e| SignFundingTransactionError::Internal(e.to_string()))?;
     let signed = sign_tx(
         unsigned,
         key_pair,
-        prev_script,
         SignatureVersion::WitnessV0,
         coin.as_ref().conf.fork_id,
     )
diff --git a/mm2src/coins/lp_coins.rs b/mm2src/coins/lp_coins.rs
index 9b6c465f7b..ad2228b055 100644
--- a/mm2src/coins/lp_coins.rs
+++ b/mm2src/coins/lp_coins.rs
@@ -1,5 +1,5 @@
 /******************************************************************************
- * Copyright © 2023 Pampex LTD and TillyHK LTD              *
+ * Copyright © 2023 Pampex LTD and TillyHK LTD                                *
  *                                                                            *
  * See the CONTRIBUTOR-LICENSE-AGREEMENT, COPYING, LICENSE-COPYRIGHT-NOTICE   *
  * and DEVELOPER-CERTIFICATE-OF-ORIGIN files in the LEGAL directory in        *
diff --git a/mm2src/coins/qrc20.rs b/mm2src/coins/qrc20.rs
index 98b12031d7..d1dd834b82 100644
--- a/mm2src/coins/qrc20.rs
+++ b/mm2src/coins/qrc20.rs
@@ -539,16 +539,11 @@ impl Qrc20Coin {
             .build()
             .await?;
 
-        let my_address = self.utxo.derivation_method.single_addr_or_err().await?;
         let key_pair = self.utxo.priv_key_policy.activated_key_or_err()?;
 
-        let prev_script = self
-            .script_for_address(&my_address)
-            .map_err(|e| Qrc20GenTxError::InvalidAddress(e.to_string()))?;
         let signed = sign_tx(
             unsigned,
             key_pair,
-            prev_script,
             self.utxo.conf.signature_version,
             self.utxo.conf.fork_id,
         )?;
diff --git a/mm2src/coins/qrc20/qrc20_tests.rs b/mm2src/coins/qrc20/qrc20_tests.rs
index 9df455a188..718e200817 100644
--- a/mm2src/coins/qrc20/qrc20_tests.rs
+++ b/mm2src/coins/qrc20/qrc20_tests.rs
@@ -74,14 +74,15 @@ fn test_withdraw_to_p2sh_address_should_fail() {
 
     let p2sh_address = AddressBuilder::new(
         UtxoAddressFormat::Standard,
-        block_on(coin.as_ref().derivation_method.unwrap_single_addr())
-            .hash()
-            .clone(),
         *block_on(coin.as_ref().derivation_method.unwrap_single_addr()).checksum_type(),
         coin.as_ref().conf.address_prefixes.clone(),
         coin.as_ref().conf.bech32_hrp.clone(),
     )
-    .as_sh()
+    .as_sh(
+        block_on(coin.as_ref().derivation_method.unwrap_single_addr())
+            .hash()
+            .clone(),
+    )
     .build()
     .expect("valid address props");
 
@@ -102,6 +103,13 @@ fn test_withdraw_to_p2sh_address_should_fail() {
 #[cfg(not(target_arch = "wasm32"))]
 #[test]
 fn test_withdraw_impl_fee_details() {
+    // priv_key of qXxsj5RtciAby9T7m98AgAATL4zTi4UwDG
+    let priv_key = [
+        3, 98, 177, 3, 108, 39, 234, 144, 131, 178, 103, 103, 127, 80, 230, 166, 53, 68, 147, 215, 42, 216, 144, 72,
+        172, 110, 180, 13, 123, 179, 10, 49,
+    ];
+    let (_ctx, coin) = qrc20_coin_for_test(priv_key, None);
+
     Qrc20Coin::get_unspent_ordered_list.mock_safe(|coin, _| {
         let cache = block_on(coin.as_ref().recently_spent_outpoints.lock());
         let unspents = vec![UnspentInfo {
@@ -111,17 +119,13 @@ fn test_withdraw_impl_fee_details() {
             },
             value: 1000000000,
             height: Default::default(),
+            script: coin
+                .script_for_address(&block_on(coin.as_ref().derivation_method.unwrap_single_addr()))
+                .unwrap(),
         }];
         MockResult::Return(Box::pin(futures::future::ok((unspents, cache))))
     });
 
-    // priv_key of qXxsj5RtciAby9T7m98AgAATL4zTi4UwDG
-    let priv_key = [
-        3, 98, 177, 3, 108, 39, 234, 144, 131, 178, 103, 103, 127, 80, 230, 166, 53, 68, 147, 215, 42, 216, 144, 72,
-        172, 110, 180, 13, 123, 179, 10, 49,
-    ];
-    let (_ctx, coin) = qrc20_coin_for_test(priv_key, None);
-
     let withdraw_req = WithdrawRequest {
         amount: 10.into(),
         from: None,
diff --git a/mm2src/coins/utxo.rs b/mm2src/coins/utxo.rs
index 6cf25fcf7f..7d13e63398 100644
--- a/mm2src/coins/utxo.rs
+++ b/mm2src/coins/utxo.rs
@@ -1,5 +1,5 @@
 /******************************************************************************
- * Copyright © 2023 Pampex LTD and TillyHK LTD              *
+ * Copyright © 2023 Pampex LTD and TillyHK LTD                                *
  *                                                                            *
  * See the CONTRIBUTOR-LICENSE-AGREEMENT, COPYING, LICENSE-COPYRIGHT-NOTICE   *
  * and DEVELOPER-CERTIFICATE-OF-ORIGIN files in the LEGAL directory in        *
@@ -309,21 +309,20 @@ pub struct CachedUnspentInfo {
     pub value: u64,
 }
 
-impl From<UnspentInfo> for CachedUnspentInfo {
-    fn from(unspent: UnspentInfo) -> CachedUnspentInfo {
+impl CachedUnspentInfo {
+    fn from_unspent_info(unspent: &UnspentInfo) -> CachedUnspentInfo {
         CachedUnspentInfo {
             outpoint: unspent.outpoint,
             value: unspent.value,
         }
     }
-}
 
-impl From<CachedUnspentInfo> for UnspentInfo {
-    fn from(cached: CachedUnspentInfo) -> UnspentInfo {
+    fn to_unspent_info(&self, script: Script) -> UnspentInfo {
         UnspentInfo {
-            outpoint: cached.outpoint,
-            value: cached.value,
+            outpoint: self.outpoint,
+            value: self.value,
             height: None,
+            script,
         }
     }
 }
@@ -350,22 +349,17 @@ impl RecentlySpentOutPoints {
     }
 
     pub fn add_spent(&mut self, inputs: Vec<UnspentInfo>, spend_tx_hash: H256, outputs: Vec<TransactionOutput>) {
-        let inputs: HashSet<_> = inputs.into_iter().map(From::from).collect();
+        let inputs: HashSet<_> = inputs.iter().map(CachedUnspentInfo::from_unspent_info).collect();
         let to_replace: HashSet<_> = outputs
-            .iter()
+            .into_iter()
             .enumerate()
-            .filter_map(|(index, output)| {
-                if output.script_pubkey == self.for_script_pubkey {
-                    Some(CachedUnspentInfo {
-                        outpoint: OutPoint {
-                            hash: spend_tx_hash,
-                            index: index as u32,
-                        },
-                        value: output.value,
-                    })
-                } else {
-                    None
-                }
+            .filter(|(_, output)| output.script_pubkey == self.for_script_pubkey)
+            .map(|(index, output)| CachedUnspentInfo {
+                outpoint: OutPoint {
+                    hash: spend_tx_hash,
+                    index: index as u32,
+                },
+                value: output.value,
             })
             .collect();
 
@@ -400,13 +394,14 @@ impl RecentlySpentOutPoints {
     pub fn replace_spent_outputs_with_cache(&self, mut outputs: HashSet<UnspentInfo>) -> HashSet<UnspentInfo> {
         let mut replacement_unspents = HashSet::new();
         outputs.retain(|unspent| {
-            let outs = self.input_to_output_map.get(&unspent.clone().into());
+            let outs = self
+                .input_to_output_map
+                .get(&CachedUnspentInfo::from_unspent_info(unspent));
+
             match outs {
                 Some(outs) => {
-                    for out in outs.iter() {
-                        if !replacement_unspents.contains(out) {
-                            replacement_unspents.insert(out.clone());
-                        }
+                    for out in outs {
+                        replacement_unspents.insert(out.clone());
                     }
                     false
                 },
@@ -416,7 +411,11 @@ impl RecentlySpentOutPoints {
         if replacement_unspents.is_empty() {
             return outputs;
         }
-        outputs.extend(replacement_unspents.into_iter().map(From::from));
+        outputs.extend(
+            replacement_unspents
+                .iter()
+                .map(|cached| cached.to_unspent_info(self.for_script_pubkey.clone().into())),
+        );
         self.replace_spent_outputs_with_cache(outputs)
     }
 }
@@ -1795,6 +1794,7 @@ where
             outpoint: input.previous_output,
             value: input.amount,
             height: None,
+            script: input.prev_script.clone(),
         })
         .collect();
 
@@ -1803,12 +1803,9 @@ where
         _ => coin.as_ref().conf.signature_version,
     };
 
-    let prev_script = utxo_common::output_script_checked(coin.as_ref(), &my_address)
-        .map_err(|e| TransactionErr::Plain(ERRL!("{}", e)))?;
     let signed = try_tx_s!(sign_tx(
         unsigned,
         key_pair,
-        prev_script,
         signature_version,
         coin.as_ref().conf.fork_id
     ));
@@ -1830,6 +1827,9 @@ pub fn output_script(address: &Address) -> Result<Script, keys::Error> {
     }
 }
 
+/// Builds transaction output script for a legacy P2PK address
+pub fn output_script_p2pk(pubkey: &Public) -> Script { Builder::build_p2pk(pubkey) }
+
 pub fn address_by_conf_and_pubkey_str(
     coin: &str,
     conf: &Json,
@@ -1854,16 +1854,15 @@ pub fn address_by_conf_and_pubkey_str(
     let conf_builder = UtxoConfBuilder::new(conf, &params, coin);
     let utxo_conf = try_s!(conf_builder.build());
     let pubkey_bytes = try_s!(hex::decode(pubkey));
-    let hash = dhash160(&pubkey_bytes);
+    let pubkey = try_s!(Public::from_slice(&pubkey_bytes));
 
     let address = AddressBuilder::new(
         addr_format,
-        hash.into(),
         utxo_conf.checksum_type,
         utxo_conf.address_prefixes,
         utxo_conf.bech32_hrp,
     )
-    .as_pkh()
+    .as_pkh_from_pk(pubkey)
     .build()?;
     address.display_address()
 }
diff --git a/mm2src/coins/utxo/bchd_grpc.rs b/mm2src/coins/utxo/bchd_grpc.rs
index 6017f3b9c0..da240508c6 100644
--- a/mm2src/coins/utxo/bchd_grpc.rs
+++ b/mm2src/coins/utxo/bchd_grpc.rs
@@ -260,6 +260,7 @@ mod bchd_grpc_tests {
                     },
                     value: 0,
                     height: None,
+                    script: Vec::new().into(),
                 },
                 slp_amount: 1000,
             },
@@ -271,6 +272,7 @@ mod bchd_grpc_tests {
                     },
                     value: 0,
                     height: None,
+                    script: Vec::new().into(),
                 },
                 slp_amount: 8999,
             },
@@ -294,6 +296,7 @@ mod bchd_grpc_tests {
                     },
                     value: 0,
                     height: None,
+                    script: Vec::new().into(),
                 },
                 slp_amount: 1000,
             },
@@ -305,6 +308,7 @@ mod bchd_grpc_tests {
                     },
                     value: 0,
                     height: None,
+                    script: Vec::new().into(),
                 },
                 slp_amount: 8999,
             },
@@ -316,6 +320,7 @@ mod bchd_grpc_tests {
                     },
                     value: 0,
                     height: None,
+                    script: Vec::new().into(),
                 },
                 slp_amount: 8999,
             },
@@ -341,6 +346,7 @@ mod bchd_grpc_tests {
                 },
                 value: 0,
                 height: None,
+                script: Vec::new().into(),
             },
             slp_amount: 999,
         };
@@ -353,6 +359,7 @@ mod bchd_grpc_tests {
                 },
                 value: 0,
                 height: None,
+                script: Vec::new().into(),
             },
             slp_amount: 8999,
         }];
@@ -386,6 +393,7 @@ mod bchd_grpc_tests {
                     },
                     value: 0,
                     height: None,
+                    script: Vec::new().into(),
                 },
                 slp_amount: 1000,
             },
@@ -397,6 +405,7 @@ mod bchd_grpc_tests {
                     },
                     value: 0,
                     height: None,
+                    script: Vec::new().into(),
                 },
                 slp_amount: 8999,
             },
diff --git a/mm2src/coins/utxo/qtum.rs b/mm2src/coins/utxo/qtum.rs
index 9d1b16723d..55c211e848 100644
--- a/mm2src/coins/utxo/qtum.rs
+++ b/mm2src/coins/utxo/qtum.rs
@@ -146,12 +146,11 @@ pub trait QtumBasedCoin: UtxoCommonOps + MarketCoinOps {
         let utxo = self.as_ref();
         AddressBuilder::new(
             self.addr_format().clone(),
-            AddressHashEnum::AddressHash(address.0.into()),
             utxo.conf.checksum_type,
             utxo.conf.address_prefixes.clone(),
             utxo.conf.bech32_hrp.clone(),
         )
-        .as_pkh()
+        .as_pkh(AddressHashEnum::AddressHash(address.0.into()))
         .build()
         .expect("valid address props")
     }
@@ -161,20 +160,6 @@ pub trait QtumBasedCoin: UtxoCommonOps + MarketCoinOps {
         contract_addr_from_utxo_addr(my_address).mm_err(Qrc20AddressError::from)
     }
 
-    fn utxo_address_from_contract_addr(&self, address: H160) -> Address {
-        let utxo = self.as_ref();
-        AddressBuilder::new(
-            self.addr_format().clone(),
-            AddressHashEnum::AddressHash(address.0.into()),
-            utxo.conf.checksum_type,
-            utxo.conf.address_prefixes.clone(),
-            utxo.conf.bech32_hrp.clone(),
-        )
-        .as_pkh()
-        .build()
-        .expect("valid address props")
-    }
-
     fn contract_address_from_raw_pubkey(&self, pubkey: &[u8]) -> Result<H160, String> {
         let utxo = self.as_ref();
         let qtum_address = try_s!(utxo_common::address_from_raw_pubkey(
diff --git a/mm2src/coins/utxo/qtum_delegation.rs b/mm2src/coins/utxo/qtum_delegation.rs
index 4a62adcd26..22235fedae 100644
--- a/mm2src/coins/utxo/qtum_delegation.rs
+++ b/mm2src/coins/utxo/qtum_delegation.rs
@@ -186,7 +186,7 @@ impl QtumCoin {
                         .map(|padded_staker_address_hex| padded_staker_address_hex.trim_start_matches('0'))
                 }) {
                 let hash = H160::from_str(raw).map_to_mm(|e| StakingInfosError::Internal(e.to_string()))?;
-                let address = self.utxo_address_from_contract_addr(hash);
+                let address = self.utxo_addr_from_contract_addr(hash);
                 Ok(Some(address.to_string()))
             } else {
                 Ok(None)
@@ -290,16 +290,7 @@ impl QtumCoin {
                 DelegationError::from_generate_tx_error(gen_tx_error, self.ticker().to_string(), utxo.decimals)
             })?;
 
-        let prev_script = self
-            .script_for_address(&my_address)
-            .map_err(|e| DelegationError::InternalError(e.to_string()))?;
-        let signed = sign_tx(
-            unsigned,
-            key_pair,
-            prev_script,
-            utxo.conf.signature_version,
-            utxo.conf.fork_id,
-        )?;
+        let signed = sign_tx(unsigned, key_pair, utxo.conf.signature_version, utxo.conf.fork_id)?;
 
         let miner_fee = data.fee_amount + data.unused_change;
         let generated_tx = GenerateQrc20TxResult {
diff --git a/mm2src/coins/utxo/rpc_clients.rs b/mm2src/coins/utxo/rpc_clients.rs
index b67946e40a..e8f86bc8e0 100644
--- a/mm2src/coins/utxo/rpc_clients.rs
+++ b/mm2src/coins/utxo/rpc_clients.rs
@@ -2,15 +2,15 @@
 #![cfg_attr(target_arch = "wasm32", allow(dead_code))]
 
 use crate::utxo::utxo_block_header_storage::BlockHeaderStorage;
-use crate::utxo::{output_script, sat_from_big_decimal, GetBlockHeaderError, GetConfirmedTxError, GetTxError,
-                  GetTxHeightError, ScripthashNotification};
+use crate::utxo::{output_script, output_script_p2pk, sat_from_big_decimal, GetBlockHeaderError, GetConfirmedTxError,
+                  GetTxError, GetTxHeightError, NumConversResult, ScripthashNotification};
 use crate::{big_decimal_from_sat_unsigned, MyAddressError, NumConversError, RpcTransportEventHandler,
             RpcTransportEventHandlerShared};
 use async_trait::async_trait;
 use chain::{BlockHeader, BlockHeaderBits, BlockHeaderNonce, OutPoint, Transaction as UtxoTx, TransactionInput,
             TxHashAlgo};
 use common::custom_futures::{select_ok_sequential, timeout::FutureTimerExt};
-use common::custom_iter::{CollectInto, TryIntoGroupMap};
+use common::custom_iter::TryIntoGroupMap;
 use common::executor::{abortable_queue, abortable_queue::AbortableQueue, AbortableSystem, SpawnFuture, Timer};
 use common::jsonrpc_client::{JsonRpcBatchClient, JsonRpcBatchResponse, JsonRpcClient, JsonRpcError, JsonRpcErrorType,
                              JsonRpcId, JsonRpcMultiClient, JsonRpcRemoteAddr, JsonRpcRequest, JsonRpcRequestEnum,
@@ -37,6 +37,7 @@ use mm2_number::{BigDecimal, BigInt, MmNumber};
 use mm2_rpc::data::legacy::ElectrumProtocol;
 #[cfg(test)] use mocktopus::macros::*;
 use rpc::v1::types::{Bytes as BytesJson, Transaction as RpcTransaction, H256 as H256Json};
+use script::Script;
 use serde_json::{self as json, Value as Json};
 use serialization::{deserialize, serialize, serialize_with_flags, CoinVariant, CompactInteger, Reader,
                     SERIALIZE_TRANSACTION_WITNESS};
@@ -256,19 +257,34 @@ pub struct UnspentInfo {
     /// The block height transaction mined in.
     /// Note None if the transaction is not mined yet.
     pub height: Option<u64>,
+    /// The script pubkey of the UTXO
+    pub script: Script,
 }
 
-impl From<ElectrumUnspent> for UnspentInfo {
-    fn from(electrum: ElectrumUnspent) -> UnspentInfo {
+impl UnspentInfo {
+    fn from_electrum(unspent: ElectrumUnspent, script: Script) -> UnspentInfo {
         UnspentInfo {
             outpoint: OutPoint {
-                hash: electrum.tx_hash.reversed().into(),
-                index: electrum.tx_pos,
+                hash: unspent.tx_hash.reversed().into(),
+                index: unspent.tx_pos,
             },
-            value: electrum.value,
-            height: electrum.height,
+            value: unspent.value,
+            height: unspent.height,
+            script,
         }
     }
+
+    fn from_native(unspent: NativeUnspent, decimals: u8, height: Option<u64>) -> NumConversResult<UnspentInfo> {
+        Ok(UnspentInfo {
+            outpoint: OutPoint {
+                hash: unspent.txid.reversed().into(),
+                index: unspent.vout,
+            },
+            value: sat_from_big_decimal(&unspent.amount.to_decimal(), decimals)?,
+            height,
+            script: unspent.script_pub_key.0.into(),
+        })
+    }
 }
 
 #[derive(Debug, PartialEq)]
@@ -758,20 +774,10 @@ impl UtxoRpcClientOps for NativeClient {
             .list_unspent_impl(0, std::i32::MAX, vec![address.to_string()])
             .map_to_mm_fut(UtxoRpcError::from)
             .and_then(move |unspents| {
-                let unspents: UtxoRpcResult<Vec<_>> = unspents
-                    .into_iter()
-                    .map(|unspent| {
-                        Ok(UnspentInfo {
-                            outpoint: OutPoint {
-                                hash: unspent.txid.reversed().into(),
-                                index: unspent.vout,
-                            },
-                            value: sat_from_big_decimal(&unspent.amount.to_decimal(), decimals)?,
-                            height: None,
-                        })
-                    })
-                    .collect();
                 unspents
+                    .into_iter()
+                    .map(|unspent| Ok(UnspentInfo::from_native(unspent, decimals, None)?))
+                    .collect::<UtxoRpcResult<_>>()
             });
         Box::new(fut)
     }
@@ -799,14 +805,7 @@ impl UtxoRpcClientOps for NativeClient {
                                 UtxoRpcError::InvalidResponse(format!("Unexpected address '{}'", unspent.address))
                             })?
                             .clone();
-                        let unspent_info = UnspentInfo {
-                            outpoint: OutPoint {
-                                hash: unspent.txid.reversed().into(),
-                                index: unspent.vout,
-                            },
-                            value: sat_from_big_decimal(&unspent.amount.to_decimal(), decimals)?,
-                            height: None,
-                        };
+                        let unspent_info = UnspentInfo::from_native(unspent, decimals, None)?;
                         Ok((orig_address, unspent_info))
                     })
                     // Collect `(Address, UnspentInfo)` items into `HashMap<Address, Vec<UnspentInfo>>` grouped by the addresses.
@@ -2237,48 +2236,67 @@ impl ElectrumClient {
 #[cfg_attr(test, mockable)]
 impl UtxoRpcClientOps for ElectrumClient {
     fn list_unspent(&self, address: &Address, _decimals: u8) -> UtxoRpcFut<Vec<UnspentInfo>> {
-        let script = try_f!(output_script(address));
-        let script_hash = electrum_script_hash(&script);
-        Box::new(
-            self.scripthash_list_unspent(&hex::encode(script_hash))
-                .map_to_mm_fut(UtxoRpcError::from)
-                .map(move |unspents| {
+        let mut output_scripts = vec![try_f!(output_script(address))];
+
+        // If the plain pubkey is available, fetch the UTXOs found in P2PK outputs as well (if any).
+        if let Some(pubkey) = address.pubkey() {
+            let p2pk_output_script = output_script_p2pk(pubkey);
+            output_scripts.push(p2pk_output_script);
+        }
+
+        let this = self.clone();
+        let fut = async move {
+            let hashes = output_scripts
+                .iter()
+                .map(|s| hex::encode(electrum_script_hash(s)))
+                .collect();
+            let unspents = this.scripthash_list_unspent_batch(hashes).compat().await?;
+
+            let unspents = unspents
+                .into_iter()
+                .zip(output_scripts)
+                .flat_map(|(unspents, output_script)| {
                     unspents
-                        .iter()
-                        .map(|unspent| UnspentInfo {
-                            outpoint: OutPoint {
-                                hash: unspent.tx_hash.reversed().into(),
-                                index: unspent.tx_pos,
-                            },
-                            value: unspent.value,
-                            height: unspent.height,
-                        })
-                        .collect()
-                }),
-        )
+                        .into_iter()
+                        .map(move |unspent| UnspentInfo::from_electrum(unspent, output_script.clone()))
+                })
+                .collect();
+            Ok(unspents)
+        };
+
+        Box::new(fut.boxed().compat())
     }
 
     fn list_unspent_group(&self, addresses: Vec<Address>, _decimals: u8) -> UtxoRpcFut<UnspentMap> {
-        let script_hashes = try_f!(addresses
+        let output_scripts = try_f!(addresses
             .iter()
-            .map(|addr| {
-                let script = output_script(addr)?;
-                let script_hash = electrum_script_hash(&script);
-                Ok(hex::encode(script_hash))
-            })
+            .map(output_script)
             .collect::<Result<Vec<_>, keys::Error>>());
 
         let this = self.clone();
         let fut = async move {
-            let unspents = this.scripthash_list_unspent_batch(script_hashes).compat().await?;
+            let hashes = output_scripts
+                .iter()
+                .map(|s| hex::encode(electrum_script_hash(s)))
+                .collect();
+            let unspents = this.scripthash_list_unspent_batch(hashes).compat().await?;
+
+            let unspents: Vec<Vec<UnspentInfo>> = unspents
+                .into_iter()
+                .zip(output_scripts)
+                .map(|(unspents, output_script)| {
+                    unspents
+                        .into_iter()
+                        .map(|unspent| UnspentInfo::from_electrum(unspent, output_script.clone()))
+                        .collect()
+                })
+                .collect();
 
             let unspent_map = addresses
                 .into_iter()
                 // `scripthash_list_unspent_batch` returns `ScriptHashUnspents` elements in the same order in which they were requested.
                 // So we can zip `addresses` and `unspents` into one iterator.
                 .zip(unspents)
-                // Map `(Address, Vec<ElectrumUnspent>)` pairs into `(Address, Vec<UnspentInfo>)`.
-                .map(|(address, electrum_unspents)| (address, electrum_unspents.collect_into()))
                 .collect();
             Ok(unspent_map)
         };
@@ -2346,12 +2364,26 @@ impl UtxoRpcClientOps for ElectrumClient {
             rpc_req!(self, "blockchain.scripthash.get_balance").into(),
             JsonRpcErrorType::Internal(err.to_string())
         )));
-        let hash = electrum_script_hash(&output_script);
-        let hash_str = hex::encode(hash);
-        Box::new(
-            self.scripthash_get_balance(&hash_str)
-                .map(move |electrum_balance| electrum_balance.to_big_decimal(decimals)),
-        )
+        let mut hashes = vec![hex::encode(electrum_script_hash(&output_script))];
+
+        // If the plain pubkey is available, fetch the balance found in P2PK output as well (if any).
+        if let Some(pubkey) = address.pubkey() {
+            let p2pk_output_script = output_script_p2pk(pubkey);
+            hashes.push(hex::encode(electrum_script_hash(&p2pk_output_script)));
+        }
+
+        let this = self.clone();
+        let fut = async move {
+            Ok(this
+                .scripthash_get_balances(hashes)
+                .compat()
+                .await?
+                .into_iter()
+                .fold(BigDecimal::from(0), |sum, electrum_balance| {
+                    sum + electrum_balance.to_big_decimal(decimals)
+                }))
+        };
+        Box::new(fut.boxed().compat())
     }
 
     fn display_balances(&self, addresses: Vec<Address>, decimals: u8) -> UtxoRpcFut<Vec<(Address, BigDecimal)>> {
diff --git a/mm2src/coins/utxo/slp.rs b/mm2src/coins/utxo/slp.rs
index 4138d3b7a8..d39d7a50a5 100644
--- a/mm2src/coins/utxo/slp.rs
+++ b/mm2src/coins/utxo/slp.rs
@@ -455,10 +455,11 @@ impl SlpToken {
             bch_unspent: UnspentInfo {
                 outpoint: OutPoint {
                     hash: tx.hash(),
-                    index: 1,
+                    index: SLP_SWAP_VOUT as u32,
                 },
                 value: 0,
                 height: None,
+                script: tx.outputs[SLP_SWAP_VOUT].script_pubkey.clone().into(),
             },
             slp_amount: slp_satoshis,
         };
@@ -555,8 +556,9 @@ impl SlpToken {
                     hash: tx.hash(),
                     index: SLP_SWAP_VOUT as u32,
                 },
-                value: tx.outputs[1].value,
+                value: tx.outputs[SLP_SWAP_VOUT].value,
                 height: None,
+                script: tx.outputs[SLP_SWAP_VOUT].script_pubkey.clone().into(),
             },
             slp_amount,
         };
@@ -606,8 +608,9 @@ impl SlpToken {
                     hash: tx.hash(),
                     index: SLP_SWAP_VOUT as u32,
                 },
-                value: tx.outputs[1].value,
+                value: tx.outputs[SLP_SWAP_VOUT].value,
                 height: None,
+                script: tx.outputs[SLP_SWAP_VOUT].script_pubkey.clone().into(),
             },
             slp_amount,
         };
@@ -677,7 +680,6 @@ impl SlpToken {
                     &unsigned,
                     i,
                     my_key_pair,
-                    my_script_pubkey.clone(),
                     self.platform_coin.as_ref().conf.signature_version,
                     self.platform_coin.as_ref().conf.fork_id,
                 )
@@ -1622,12 +1624,6 @@ impl MmCoin for SlpToken {
                 ));
             }
 
-            let my_address = coin
-                .platform_coin
-                .as_ref()
-                .derivation_method
-                .single_addr_or_err()
-                .await?;
             let key_pair = coin.platform_coin.as_ref().priv_key_policy.activated_key_or_err()?;
 
             let address = CashAddress::decode(&req.to).map_to_mm(WithdrawError::InvalidAddress)?;
@@ -1694,14 +1690,9 @@ impl MmCoin for SlpToken {
                 WithdrawError::from_generate_tx_error(gen_tx_error, coin.platform_ticker().into(), platform_decimals)
             })?;
 
-            let prev_script = coin
-                .platform_coin
-                .script_for_address(&my_address)
-                .map_err(|e| WithdrawError::InvalidAddress(e.to_string()))?;
             let signed = sign_tx(
                 unsigned,
                 key_pair,
-                prev_script,
                 coin.platform_conf().signature_version,
                 coin.platform_conf().fork_id,
             )?;
diff --git a/mm2src/coins/utxo/utxo_builder/utxo_coin_builder.rs b/mm2src/coins/utxo/utxo_builder/utxo_coin_builder.rs
index edf34ebb65..0b07d1596c 100644
--- a/mm2src/coins/utxo/utxo_builder/utxo_coin_builder.rs
+++ b/mm2src/coins/utxo/utxo_builder/utxo_coin_builder.rs
@@ -171,12 +171,11 @@ pub trait UtxoFieldsWithIguanaSecretBuilder: UtxoCoinBuilderCommonOps {
         let addr_format = self.address_format()?;
         let my_address = AddressBuilder::new(
             addr_format,
-            AddressHashEnum::AddressHash(key_pair.public().address_hash()),
             conf.checksum_type,
             conf.address_prefixes.clone(),
             conf.bech32_hrp.clone(),
         )
-        .as_pkh()
+        .as_pkh_from_pk(*key_pair.public())
         .build()
         .map_to_mm(UtxoCoinBuildError::Internal)?;
         let derivation_method = DerivationMethod::SingleAddress(my_address);
@@ -276,12 +275,11 @@ where
     let addr_format = builder.address_format()?;
     let my_address = AddressBuilder::new(
         addr_format,
-        AddressHashEnum::AddressHash(key_pair.public().address_hash()),
         conf.checksum_type,
         conf.address_prefixes.clone(),
         conf.bech32_hrp.clone(),
     )
-    .as_pkh()
+    .as_pkh_from_pk(*key_pair.public())
     .build()
     .map_to_mm(UtxoCoinBuildError::Internal)?;
 
diff --git a/mm2src/coins/utxo/utxo_common.rs b/mm2src/coins/utxo/utxo_common.rs
index c757e942db..da916c6cc8 100644
--- a/mm2src/coins/utxo/utxo_common.rs
+++ b/mm2src/coins/utxo/utxo_common.rs
@@ -310,19 +310,18 @@ pub fn addresses_from_script<T: UtxoCommonOps>(coin: &T, script: &Script) -> Res
             let (addr_format, build_option) = match dst.kind {
                 AddressScriptType::P2PKH => (
                     coin.addr_format_for_standard_scripts(),
-                    AddressBuilderOption::BuildAsPubkeyHash,
+                    AddressBuilderOption::PubkeyHash(dst.hash),
                 ),
                 AddressScriptType::P2SH => (
                     coin.addr_format_for_standard_scripts(),
-                    AddressBuilderOption::BuildAsScriptHash,
+                    AddressBuilderOption::ScriptHash(dst.hash),
                 ),
-                AddressScriptType::P2WPKH => (UtxoAddressFormat::Segwit, AddressBuilderOption::BuildAsPubkeyHash),
-                AddressScriptType::P2WSH => (UtxoAddressFormat::Segwit, AddressBuilderOption::BuildAsScriptHash),
+                AddressScriptType::P2WPKH => (UtxoAddressFormat::Segwit, AddressBuilderOption::PubkeyHash(dst.hash)),
+                AddressScriptType::P2WSH => (UtxoAddressFormat::Segwit, AddressBuilderOption::ScriptHash(dst.hash)),
             };
 
             AddressBuilder::new(
                 addr_format,
-                dst.hash,
                 conf.checksum_type,
                 conf.address_prefixes.clone(),
                 conf.bech32_hrp.clone(),
@@ -514,9 +513,9 @@ impl<'a, T: AsRef<UtxoCoinFields> + UtxoTxGenerationOps> UtxoTxBuilder<'a, T> {
             .inputs
             .extend(inputs.into_iter().map(|input| UnsignedTransactionInput {
                 previous_output: input.outpoint,
+                prev_script: input.script,
                 sequence: SEQUENCE_FINAL,
                 amount: input.value,
-                witness: Vec::new(),
             }));
         self
     }
@@ -589,9 +588,9 @@ impl<'a, T: AsRef<UtxoCoinFields> + UtxoTxGenerationOps> UtxoTxBuilder<'a, T> {
                     }
                     if let Some(min_relay) = self.min_relay_fee {
                         if self.tx_fee < min_relay {
-                            outputs_plus_fee -= self.tx_fee;
-                            outputs_plus_fee += min_relay;
-                            self.tx_fee = min_relay;
+                            let fee_diff = min_relay - self.tx_fee;
+                            outputs_plus_fee += fee_diff;
+                            self.tx_fee += fee_diff;
                         }
                     }
                     self.sum_inputs >= outputs_plus_fee
@@ -681,17 +680,17 @@ impl<'a, T: AsRef<UtxoCoinFields> + UtxoTxGenerationOps> UtxoTxBuilder<'a, T> {
         };
 
         for utxo in self.available_inputs.clone() {
+            if self.update_fee_and_check_completeness(from.addr_format(), &actual_tx_fee) {
+                break;
+            }
+
             self.tx.inputs.push(UnsignedTransactionInput {
                 previous_output: utxo.outpoint,
+                prev_script: utxo.script,
                 sequence: SEQUENCE_FINAL,
                 amount: utxo.value,
-                witness: vec![],
             });
             self.sum_inputs += utxo.value;
-
-            if self.update_fee_and_check_completeness(from.addr_format(), &actual_tx_fee) {
-                break;
-            }
         }
 
         match self.fee_policy {
@@ -769,12 +768,13 @@ impl<'a, T: AsRef<UtxoCoinFields> + UtxoTxGenerationOps> UtxoTxBuilder<'a, T> {
                 .find(|input| input.previous_output == utxo.outpoint)
             {
                 input.amount = utxo.value;
+                input.prev_script = utxo.script;
             } else {
                 self.tx.inputs.push(UnsignedTransactionInput {
                     previous_output: utxo.outpoint,
+                    prev_script: utxo.script,
                     sequence: SEQUENCE_FINAL,
                     amount: utxo.value,
-                    witness: vec![],
                 });
             }
         }
@@ -913,8 +913,8 @@ async fn p2sh_spending_tx_preimage<T: UtxoCommonOps>(
                 hash: prev_tx.hash(),
                 index: DEFAULT_SWAP_VOUT as u32,
             },
+            prev_script: Vec::new().into(),
             amount,
-            witness: Vec::new(),
         }],
         outputs,
         expiry_height: 0,
@@ -1212,12 +1212,11 @@ pub async fn sign_and_send_taker_funding_spend<T: UtxoCommonOps>(
         );
         let payment_address = AddressBuilder::new(
             UtxoAddressFormat::Standard,
-            AddressHashEnum::AddressHash(dhash160(&payment_redeem_script)),
             coin.as_ref().conf.checksum_type,
             coin.as_ref().conf.address_prefixes.clone(),
             coin.as_ref().conf.bech32_hrp.clone(),
         )
-        .as_sh()
+        .as_sh(dhash160(&payment_redeem_script).into())
         .build()
         .map_err(TransactionErr::Plain)?;
         let payment_address_str = payment_address.to_string();
@@ -2443,12 +2442,11 @@ pub fn check_if_my_payment_sent<T: UtxoCommonOps + SwapOps>(
             UtxoRpcClientEnum::Native(client) => {
                 let target_addr = AddressBuilder::new(
                     coin.addr_format_for_standard_scripts(),
-                    hash.into(),
                     coin.as_ref().conf.checksum_type,
                     coin.as_ref().conf.address_prefixes.clone(),
                     coin.as_ref().conf.bech32_hrp.clone(),
                 )
-                .as_sh()
+                .as_sh(hash.into())
                 .build()?;
                 let target_addr = target_addr.to_string();
                 let is_imported = try_s!(client.is_address_imported(&target_addr).await);
@@ -2687,25 +2685,23 @@ pub fn send_raw_tx_bytes(
 }
 
 /// Helper to load unspent outputs from cache or rpc
-/// also returns first previous scriptpubkey
 async fn get_unspents_for_inputs(
     coin: &UtxoCoinFields,
     inputs: &Vec<TransactionInput>,
-) -> Result<(Option<Script>, Vec<UnspentInfo>), RawTransactionError> {
+) -> Result<Vec<UnspentInfo>, RawTransactionError> {
     let txids_reversed = inputs
         .iter()
         .map(|input| input.previous_output.hash.reversed().into()) // reverse hashes to send to electrum
         .collect::<HashSet<H256Json>>();
 
     if txids_reversed.is_empty() {
-        return Ok((None, vec![]));
+        return Ok(vec![]);
     }
 
     let prev_txns_loaded = utxo_common::get_verbose_transactions_from_cache_or_rpc(coin, txids_reversed)
         .await
         .map_err(|err| RawTransactionError::InvalidParam(err.to_string()))?;
 
-    let mut prev_script = None;
     let mut unspents_loaded = Vec::with_capacity(inputs.len());
 
     for input in inputs {
@@ -2725,15 +2721,13 @@ async fn get_unspents_for_inputs(
                 input.previous_output.hash, input.previous_output.index
             )));
         }
-        if prev_script.is_none() {
-            // get first previous script pubkey
-            let script_bytes: Vec<u8> = prev_tx.vout[input.previous_output.index as usize]
+        let prev_script = Script::from(
+            prev_tx.vout[input.previous_output.index as usize]
                 .clone()
                 .script
                 .hex
-                .into();
-            prev_script = Some(Script::from(script_bytes));
-        }
+                .to_vec(),
+        );
         let prev_amount = prev_tx.vout[input.previous_output.index as usize]
             .value
             .ok_or_else(|| {
@@ -2749,9 +2743,10 @@ async fn get_unspents_for_inputs(
             value: sat_from_big_decimal(&prev_amount, coin.decimals)
                 .expect("Conversion to satoshi from bigdecimal must be valid"),
             height: None,
+            script: prev_script,
         });
     }
-    Ok((prev_script, unspents_loaded))
+    Ok(unspents_loaded)
 }
 
 /// Takes args with a raw transaction in hexadecimal format and previous transactions data as input
@@ -2777,15 +2772,13 @@ async fn sign_raw_utxo_tx<T: AsRef<UtxoCoinFields> + UtxoTxGenerationOps>(
         hex::decode(args.tx_hex.as_bytes()).map_to_mm(|e| RawTransactionError::DecodeError(e.to_string()))?;
     let tx: UtxoTx = deserialize(tx_bytes.as_slice()).map_to_mm(|e| RawTransactionError::DecodeError(e.to_string()))?;
 
-    let mut prev_script = HashSet::new();
     let mut unspents = vec![];
 
     if let Some(prev_txns) = &args.prev_txns {
         for prev_utxo in prev_txns.iter() {
-            // get first previous utxo script assuming all are the same
-            let script_bytes = hex::decode(prev_utxo.clone().script_pub_key)
-                .map_to_mm(|e| RawTransactionError::DecodeError(e.to_string()))?;
-            prev_script.insert(Script::from(script_bytes));
+            let prev_script = hex::decode(prev_utxo.clone().script_pub_key)
+                .map_to_mm(|e| RawTransactionError::DecodeError(e.to_string()))?
+                .into();
 
             let prev_hash = hex::decode(prev_utxo.tx_hash.as_bytes())
                 .map_to_mm(|e| RawTransactionError::DecodeError(e.to_string()))?;
@@ -2798,6 +2791,7 @@ async fn sign_raw_utxo_tx<T: AsRef<UtxoCoinFields> + UtxoTxGenerationOps>(
                 value: sat_from_big_decimal(&prev_utxo.amount, coin.as_ref().decimals)
                     .expect("conversion satoshi from bigdecimal must be valid"),
                 height: None,
+                script: prev_script,
             });
         }
     }
@@ -2805,21 +2799,14 @@ async fn sign_raw_utxo_tx<T: AsRef<UtxoCoinFields> + UtxoTxGenerationOps>(
     let inputs_to_load = tx
         .inputs()
         .iter()
+        .filter(|input| !unspents.iter().any(|u| u.outpoint == input.previous_output))
         .cloned()
-        .filter(|input| {
-            !unspents.iter().any(|u| {
-                u.outpoint.hash == input.previous_output.hash && u.outpoint.index == input.previous_output.index
-            })
-        })
         .collect::<Vec<TransactionInput>>();
 
     // If some previous utxos are not provided in the params load them from the chain
     if !inputs_to_load.is_empty() {
-        let (loaded_script, loaded_unspents) = get_unspents_for_inputs(coin.as_ref(), &inputs_to_load).await?;
+        let loaded_unspents = get_unspents_for_inputs(coin.as_ref(), &inputs_to_load).await?;
         unspents.extend(loaded_unspents.into_iter());
-        if let Some(loaded_script) = loaded_script {
-            prev_script.insert(loaded_script);
-        }
     }
 
     // TODO: use zeroise for privkey
@@ -2838,31 +2825,9 @@ async fn sign_raw_utxo_tx<T: AsRef<UtxoCoinFields> + UtxoTxGenerationOps>(
         .map_err(|e| RawTransactionError::InvalidParam(e.to_string()))?;
     debug!("Unsigned tx = {:?} for signing", unsigned);
 
-    let prev_script = match prev_script.len() {
-        0 => {
-            return MmError::err(RawTransactionError::NonExistentPrevOutputError(String::from(
-                "no previous script",
-            )))
-        },
-        1 => prev_script.into_iter().next().unwrap(),
-        _ => {
-            return MmError::err(RawTransactionError::InvalidParam(String::from(
-                "spends are from same address only",
-            )))
-        },
-    };
-    let signature_version = match prev_script.is_pay_to_witness_key_hash() {
-        true => SignatureVersion::WitnessV0,
-        _ => coin.as_ref().conf.signature_version,
-    };
-    let tx_signed = sign_tx(
-        unsigned,
-        key_pair,
-        prev_script,
-        signature_version,
-        coin.as_ref().conf.fork_id,
-    )
-    .map_err(|err| RawTransactionError::SigningError(err.to_string()))?;
+    let signature_version = coin.as_ref().conf.signature_version;
+    let tx_signed = sign_tx(unsigned, key_pair, signature_version, coin.as_ref().conf.fork_id)
+        .map_err(|err| RawTransactionError::SigningError(err.to_string()))?;
 
     let tx_signed_bytes = serialize_with_flags(&tx_signed, SERIALIZE_TRANSACTION_WITNESS);
     Ok(RawTransactionRes {
@@ -4266,26 +4231,20 @@ pub fn address_from_raw_pubkey(
     hrp: Option<String>,
     addr_format: UtxoAddressFormat,
 ) -> Result<Address, String> {
-    AddressBuilder::new(
-        addr_format,
-        try_s!(Public::from_slice(pub_key)).address_hash().into(),
-        checksum_type,
-        prefixes,
-        hrp,
-    )
-    .as_pkh()
-    .build()
+    AddressBuilder::new(addr_format, checksum_type, prefixes, hrp)
+        .as_pkh_from_pk(try_s!(Public::from_slice(pub_key)))
+        .build()
 }
 
 pub fn address_from_pubkey(
-    pub_key: &Public,
+    pubkey: &Public,
     prefixes: NetworkAddressPrefixes,
     checksum_type: ChecksumType,
     hrp: Option<String>,
     addr_format: UtxoAddressFormat,
 ) -> Address {
-    AddressBuilder::new(addr_format, pub_key.address_hash().into(), checksum_type, prefixes, hrp)
-        .as_pkh()
+    AddressBuilder::new(addr_format, checksum_type, prefixes, hrp)
+        .as_pkh_from_pk(*pubkey)
         .build()
         .expect("valid address props")
 }
@@ -4486,12 +4445,11 @@ where
 
     let payment_address = AddressBuilder::new(
         UtxoAddressFormat::Standard,
-        redeem_script_hash.into(),
         coin.as_ref().conf.checksum_type,
         coin.as_ref().conf.address_prefixes.clone(),
         coin.as_ref().conf.bech32_hrp.clone(),
     )
-    .as_sh()
+    .as_sh(redeem_script_hash.into())
     .build()?;
     let result = SwapPaymentOutputsResult {
         payment_address,
@@ -4958,12 +4916,11 @@ where
     // import funding address in native mode to track funding tx spend
     let funding_address = AddressBuilder::new(
         AddressFormat::Standard,
-        dhash160(&redeem_script).into(),
         coin.as_ref().conf.checksum_type,
         coin.as_ref().conf.address_prefixes.clone(),
         coin.as_ref().conf.bech32_hrp.clone(),
     )
-    .as_sh()
+    .as_sh(dhash160(&redeem_script).into())
     .build()
     .map_to_mm(ValidateSwapV2TxError::Internal)?;
 
diff --git a/mm2src/coins/utxo/utxo_common_tests.rs b/mm2src/coins/utxo/utxo_common_tests.rs
index 53e89599f3..851f4a0644 100644
--- a/mm2src/coins/utxo/utxo_common_tests.rs
+++ b/mm2src/coins/utxo/utxo_common_tests.rs
@@ -83,16 +83,10 @@ pub(super) fn utxo_coin_fields_for_test(
     } else {
         UtxoAddressFormat::Standard
     };
-    let my_address = AddressBuilder::new(
-        addr_format,
-        key_pair.public().address_hash().into(),
-        checksum_type,
-        prefixes,
-        hrp,
-    )
-    .as_pkh()
-    .build()
-    .expect("valid address props");
+    let my_address = AddressBuilder::new(addr_format, checksum_type, prefixes, hrp)
+        .as_pkh_from_pk(*key_pair.public())
+        .build()
+        .expect("valid address props");
     let my_script_pubkey = Builder::build_p2pkh(my_address.hash()).to_bytes();
 
     let priv_key_policy = PrivKeyPolicy::Iguana(key_pair);
diff --git a/mm2src/coins/utxo/utxo_tests.rs b/mm2src/coins/utxo/utxo_tests.rs
index a358d224aa..c2af71d811 100644
--- a/mm2src/coins/utxo/utxo_tests.rs
+++ b/mm2src/coins/utxo/utxo_tests.rs
@@ -189,6 +189,7 @@ fn test_generate_transaction() {
         value: 10000000000,
         outpoint: OutPoint::default(),
         height: Default::default(),
+        script: Vec::new().into(),
     }];
 
     let outputs = vec![TransactionOutput {
@@ -207,6 +208,7 @@ fn test_generate_transaction() {
         value: 100000,
         outpoint: OutPoint::default(),
         height: Default::default(),
+        script: Vec::new().into(),
     }];
 
     let outputs = vec![TransactionOutput {
@@ -231,6 +233,7 @@ fn test_generate_transaction() {
         value: 100000,
         outpoint: OutPoint::default(),
         height: Default::default(),
+        script: Vec::new().into(),
     }];
 
     let outputs = vec![TransactionOutput {
@@ -258,6 +261,7 @@ fn test_generate_transaction() {
         value: 100000,
         outpoint: OutPoint::default(),
         height: Default::default(),
+        script: Vec::new().into(),
     }];
 
     let outputs = vec![TransactionOutput {
@@ -579,6 +583,9 @@ fn test_withdraw_impl_set_fixed_fee() {
             },
             value: 1000000000,
             height: Default::default(),
+            script: coin
+                .script_for_address(&block_on(coin.as_ref().derivation_method.unwrap_single_addr()))
+                .unwrap(),
         }];
         MockResult::Return(Box::pin(futures::future::ok((unspents, cache))))
     });
@@ -621,6 +628,9 @@ fn test_withdraw_impl_sat_per_kb_fee() {
             },
             value: 1000000000,
             height: Default::default(),
+            script: coin
+                .script_for_address(&block_on(coin.as_ref().derivation_method.unwrap_single_addr()))
+                .unwrap(),
         }];
         MockResult::Return(Box::pin(futures::future::ok((unspents, cache))))
     });
@@ -666,6 +676,9 @@ fn test_withdraw_impl_sat_per_kb_fee_amount_equal_to_max() {
             },
             value: 1000000000,
             height: Default::default(),
+            script: coin
+                .script_for_address(&block_on(coin.as_ref().derivation_method.unwrap_single_addr()))
+                .unwrap(),
         }];
         MockResult::Return(Box::pin(futures::future::ok((unspents, cache))))
     });
@@ -713,6 +726,9 @@ fn test_withdraw_impl_sat_per_kb_fee_amount_equal_to_max_dust_included_to_fee()
             },
             value: 1000000000,
             height: Default::default(),
+            script: coin
+                .script_for_address(&block_on(coin.as_ref().derivation_method.unwrap_single_addr()))
+                .unwrap(),
         }];
         MockResult::Return(Box::pin(futures::future::ok((unspents, cache))))
     });
@@ -760,6 +776,9 @@ fn test_withdraw_impl_sat_per_kb_fee_amount_over_max() {
             },
             value: 1000000000,
             height: Default::default(),
+            script: coin
+                .script_for_address(&block_on(coin.as_ref().derivation_method.unwrap_single_addr()))
+                .unwrap(),
         }];
         MockResult::Return(Box::pin(futures::future::ok((unspents, cache))))
     });
@@ -794,6 +813,9 @@ fn test_withdraw_impl_sat_per_kb_fee_max() {
             },
             value: 1000000000,
             height: Default::default(),
+            script: coin
+                .script_for_address(&block_on(coin.as_ref().derivation_method.unwrap_single_addr()))
+                .unwrap(),
         }];
         MockResult::Return(Box::pin(futures::future::ok((unspents, cache))))
     });
@@ -837,7 +859,7 @@ fn test_withdraw_kmd_rewards_impl(
 ) {
     let verbose: RpcTransaction = json::from_str(verbose_serialized).unwrap();
     let unspent_height = verbose.height;
-    UtxoStandardCoin::get_unspent_ordered_list.mock_safe(move |coin, _| {
+    UtxoStandardCoin::get_unspent_ordered_list.mock_safe(move |coin: &UtxoStandardCoin, _| {
         let tx: UtxoTx = tx_hex.into();
         let unspents = vec![UnspentInfo {
             outpoint: OutPoint {
@@ -846,6 +868,9 @@ fn test_withdraw_kmd_rewards_impl(
             },
             value: tx.outputs[0].value,
             height: unspent_height,
+            script: coin
+                .script_for_address(&block_on(coin.as_ref().derivation_method.unwrap_single_addr()))
+                .unwrap(),
         }];
         let cache = block_on(coin.as_ref().recently_spent_outpoints.lock());
         MockResult::Return(Box::pin(futures::future::ok((unspents, cache))))
@@ -918,6 +943,10 @@ fn test_withdraw_kmd_rewards_zero() {
 #[test]
 #[cfg(not(target_arch = "wasm32"))]
 fn test_withdraw_rick_rewards_none() {
+    let client = NativeClient(Arc::new(NativeClientImpl::default()));
+
+    let coin = utxo_coin_for_test(UtxoRpcClientEnum::Native(client), None, false);
+
     // https://rick.explorer.dexstats.info/tx/7181400be323acc6b5f3164240e6c4601ff4c252f40ce7649f87e81634330209
     const TX_HEX: &str = "0400008085202f8901df8119c507aa61d32332cd246dbfeb3818a4f96e76492454c1fbba5aa097977e000000004847304402205a7e229ea6929c97fd6dde254c19e4eb890a90353249721701ae7a1c477d99c402206a8b7c5bf42b5095585731d6b4c589ce557f63c20aed69ff242eca22ecfcdc7a01feffffff02d04d1bffbc050000232102afdbba3e3c90db5f0f4064118f79cf308f926c68afd64ea7afc930975663e4c4ac402dd913000000001976a9143e17014eca06281ee600adffa34b4afb0922a22288ac2bdab86035a00e000000000000000000000000";
 
@@ -930,15 +959,14 @@ fn test_withdraw_rick_rewards_none() {
             },
             value: tx.outputs[0].value,
             height: Some(1431628),
+            script: coin
+                .script_for_address(&block_on(coin.as_ref().derivation_method.unwrap_single_addr()))
+                .unwrap(),
         }];
         let cache = block_on(coin.as_ref().recently_spent_outpoints.lock());
         MockResult::Return(Box::pin(futures::future::ok((unspents, cache))))
     });
 
-    let client = NativeClient(Arc::new(NativeClientImpl::default()));
-
-    let coin = utxo_coin_for_test(UtxoRpcClientEnum::Native(client), None, false);
-
     let withdraw_req = WithdrawRequest {
         amount: BigDecimal::from_str("0.00001").unwrap(),
         from: None,
@@ -1143,6 +1171,7 @@ fn test_generate_transaction_relay_fee_is_used_when_dynamic_fee_is_lower() {
         value: 1000000000,
         outpoint: OutPoint::default(),
         height: Default::default(),
+        script: Vec::new().into(),
     }];
 
     let outputs = vec![TransactionOutput {
@@ -1185,6 +1214,7 @@ fn test_generate_transaction_relay_fee_is_used_when_dynamic_fee_is_lower_and_ded
         value: 1000000000,
         outpoint: OutPoint::default(),
         height: Default::default(),
+        script: Vec::new().into(),
     }];
 
     let outputs = vec![TransactionOutput {
@@ -1231,6 +1261,7 @@ fn test_generate_tx_fee_is_correct_when_dynamic_fee_is_larger_than_relay() {
             value: 1000000000,
             outpoint: OutPoint::default(),
             height: Default::default(),
+            script: Vec::new().into(),
         };
         20
     ];
@@ -1762,6 +1793,7 @@ fn test_qtum_my_balance() {
                 },
                 value: 5000000000,
                 height: Default::default(),
+                script: Vec::new().into(),
             },
             UnspentInfo {
                 outpoint: OutPoint {
@@ -1770,6 +1802,7 @@ fn test_qtum_my_balance() {
                 },
                 value: 1600000000,
                 height: Default::default(),
+                script: Vec::new().into(),
             },
         ];
         // unspendable (2.0)
@@ -1780,6 +1813,7 @@ fn test_qtum_my_balance() {
             },
             value: 200000000,
             height: Default::default(),
+            script: Vec::new().into(),
         }];
         MockResult::Return(Box::pin(futures::future::ok((
             MatureUnspentList { mature, immature },
@@ -1870,6 +1904,7 @@ fn test_get_mature_unspent_ordered_map_from_cache_impl(
             },
             value: 1000000000,
             height: unspent_height,
+            script: Vec::new().into(),
         }];
         MockResult::Return(Box::new(futures01::future::ok(unspents)))
     });
@@ -2034,8 +2069,8 @@ fn test_native_client_unspents_filtered_using_tx_cache_single_tx_in_cache() {
     let coin = utxo_coin_for_test(UtxoRpcClientEnum::Native(client), None, false);
 
     let address: Address = Address::from_legacyaddress("RGfFZaaNV68uVe1uMf6Y37Y8E1i2SyYZBN", &KMD_PREFIXES).unwrap();
-    block_on(coin.as_ref().recently_spent_outpoints.lock()).for_script_pubkey =
-        Builder::build_p2pkh(address.hash()).to_bytes();
+    let output_script = coin.script_for_address(&address).unwrap();
+    block_on(coin.as_ref().recently_spent_outpoints.lock()).for_script_pubkey = output_script.clone().into();
 
     // https://morty.explorer.dexstats.info/tx/31c7aaae89ab1c39febae164a3190a86ed7c6c6f8c9dc98ec28d508b7929d347
     let tx: UtxoTx = "0400008085202f89027f57730fcbbc2c72fb18bcc3766a713044831a117bb1cade3ed88644864f7333020000006a47304402206e3737b2fcf078b61b16fa67340cc3e79c5d5e2dc9ffda09608371552a3887450220460a332aa1b8ad8f2de92d319666f70751078b221199951f80265b4f7cef8543012102d8c948c6af848c588517288168faa397d6ba3ea924596d03d1d84f224b5123c2ffffffff42b916a80430b80a77e114445b08cf120735447a524de10742fac8f6a9d4170f000000006a473044022004aa053edafb9d161ea8146e0c21ed1593aa6b9404dd44294bcdf920a1695fd902202365eac15dbcc5e9f83e2eed56a8f2f0e5aded36206f9c3fabc668fd4665fa2d012102d8c948c6af848c588517288168faa397d6ba3ea924596d03d1d84f224b5123c2ffffffff03547b16000000000017a9143e8ad0e2bf573d32cb0b3d3a304d9ebcd0c2023b870000000000000000166a144e2b3c0323ab3c2dc6f86dc5ec0729f11e42f56103970400000000001976a91450f4f098306f988d8843004689fae28c83ef16e888ac89c5925f000000000000000000000000000000".into();
@@ -2044,11 +2079,13 @@ fn test_native_client_unspents_filtered_using_tx_cache_single_tx_in_cache() {
             outpoint: tx.inputs[0].previous_output,
             value: 886737,
             height: Some(642293),
+            script: output_script.clone(),
         },
         UnspentInfo {
             outpoint: tx.inputs[1].previous_output,
             value: 88843,
             height: Some(642293),
+            script: output_script,
         },
     ];
 
@@ -2069,6 +2106,8 @@ fn test_native_client_unspents_filtered_using_tx_cache_single_tx_in_cache() {
         },
         value: tx.outputs[2].value,
         height: None,
+        // Should be the same as: Some(output_script.clone()),
+        script: tx.outputs[2].script_pubkey.clone().into(),
     };
     assert_eq!(vec![expected_unspent], unspents_ordered);
 }
@@ -2077,11 +2116,11 @@ fn test_native_client_unspents_filtered_using_tx_cache_single_tx_in_cache() {
 #[cfg(not(target_arch = "wasm32"))]
 fn test_native_client_unspents_filtered_using_tx_cache_single_several_chained_txs_in_cache() {
     let client = native_client_for_test();
-    let coin = utxo_coin_fields_for_test(UtxoRpcClientEnum::Native(client), None, false);
+    let coin = utxo_coin_for_test(UtxoRpcClientEnum::Native(client), None, false);
 
     let address: Address = Address::from_legacyaddress("RGfFZaaNV68uVe1uMf6Y37Y8E1i2SyYZBN", &KMD_PREFIXES).unwrap();
-    block_on(coin.recently_spent_outpoints.lock()).for_script_pubkey = Builder::build_p2pkh(address.hash()).to_bytes();
-    let coin = utxo_coin_from_fields(coin);
+    let output_script = coin.script_for_address(&address).unwrap();
+    block_on(coin.as_ref().recently_spent_outpoints.lock()).for_script_pubkey = output_script.clone().into();
 
     // https://morty.explorer.dexstats.info/tx/31c7aaae89ab1c39febae164a3190a86ed7c6c6f8c9dc98ec28d508b7929d347
     let tx_0: UtxoTx = "0400008085202f89027f57730fcbbc2c72fb18bcc3766a713044831a117bb1cade3ed88644864f7333020000006a47304402206e3737b2fcf078b61b16fa67340cc3e79c5d5e2dc9ffda09608371552a3887450220460a332aa1b8ad8f2de92d319666f70751078b221199951f80265b4f7cef8543012102d8c948c6af848c588517288168faa397d6ba3ea924596d03d1d84f224b5123c2ffffffff42b916a80430b80a77e114445b08cf120735447a524de10742fac8f6a9d4170f000000006a473044022004aa053edafb9d161ea8146e0c21ed1593aa6b9404dd44294bcdf920a1695fd902202365eac15dbcc5e9f83e2eed56a8f2f0e5aded36206f9c3fabc668fd4665fa2d012102d8c948c6af848c588517288168faa397d6ba3ea924596d03d1d84f224b5123c2ffffffff03547b16000000000017a9143e8ad0e2bf573d32cb0b3d3a304d9ebcd0c2023b870000000000000000166a144e2b3c0323ab3c2dc6f86dc5ec0729f11e42f56103970400000000001976a91450f4f098306f988d8843004689fae28c83ef16e888ac89c5925f000000000000000000000000000000".into();
@@ -2090,11 +2129,13 @@ fn test_native_client_unspents_filtered_using_tx_cache_single_several_chained_tx
             outpoint: tx_0.inputs[0].previous_output,
             value: 886737,
             height: Some(642293),
+            script: output_script.clone(),
         },
         UnspentInfo {
             outpoint: tx_0.inputs[1].previous_output,
             value: 88843,
             height: Some(642293),
+            script: output_script.clone(),
         },
     ];
     block_on(coin.as_ref().recently_spent_outpoints.lock()).add_spent(spent_by_tx_0.clone(), tx_0.hash(), tx_0.outputs);
@@ -2106,16 +2147,19 @@ fn test_native_client_unspents_filtered_using_tx_cache_single_several_chained_tx
             outpoint: tx_1.inputs[0].previous_output,
             value: 300803,
             height: Some(642293),
+            script: output_script.clone(),
         },
         UnspentInfo {
             outpoint: tx_1.inputs[1].previous_output,
             value: 888544,
             height: Some(642293),
+            script: output_script.clone(),
         },
         UnspentInfo {
             outpoint: tx_1.inputs[2].previous_output,
             value: 888642,
             height: Some(642293),
+            script: output_script.clone(),
         },
     ];
     block_on(coin.as_ref().recently_spent_outpoints.lock()).add_spent(spent_by_tx_1.clone(), tx_1.hash(), tx_1.outputs);
@@ -2126,11 +2170,13 @@ fn test_native_client_unspents_filtered_using_tx_cache_single_several_chained_tx
             outpoint: tx_2.inputs[0].previous_output,
             value: 832532,
             height: Some(642293),
+            script: output_script.clone(),
         },
         UnspentInfo {
             outpoint: tx_2.inputs[1].previous_output,
             value: 888823,
             height: Some(642293),
+            script: output_script,
         },
     ];
     block_on(coin.as_ref().recently_spent_outpoints.lock()).add_spent(
@@ -2156,6 +2202,58 @@ fn test_native_client_unspents_filtered_using_tx_cache_single_several_chained_tx
         },
         value: tx_2.outputs[2].value,
         height: None,
+        // Should be the same as: Some(output_script.clone()),
+        script: tx_2.outputs[2].script_pubkey.clone().into(),
+    };
+    assert_eq!(vec![expected_unspent], unspents_ordered);
+}
+
+#[test]
+#[cfg(not(target_arch = "wasm32"))]
+fn test_native_client_unspents_p2pk_filtered_using_tx_cache_single_tx_in_cache() {
+    let client = native_client_for_test();
+    let coin = utxo_coin_for_test(UtxoRpcClientEnum::Native(client), None, false);
+
+    let address: Address = Address::from_legacyaddress("RWdLNGQ428ZmhbMs6sVi42KPUbiKYKhiLr", &KMD_PREFIXES).unwrap();
+    let output_script = coin.script_for_address(&address).unwrap();
+    block_on(coin.as_ref().recently_spent_outpoints.lock()).for_script_pubkey = output_script.into();
+
+    // https://morty.explorer.dexstats.info/tx/e5b6a8c98bc802cf764430d79f2a8fdb1373ecf8bb0fb07e9ffea559083e9ead
+    let tx: UtxoTx = "0400008085202f8902c828be61a42ca160a5cbf549b74cb3ac0a8011eb32924b61dd22cb8153dd0c9c000000004948304502210094e99bb9369d2b3c4f13b8ffd7c4abacbdb2b5ee06d9453b13c23d9a924e1b34022005e5939999537f8eb901b6a37fb0776d5f6196fc7a38b1ecc8b043e84ea420bb01ffffffff2ec39160776dc986b7619e07f077d719a3247e1c0ab2148213013a34d79fd56a000000006b483045022100909ec2d09276891d48765f101d6501ef0606af971309f86a814042421f420bc202200bc376f0186aeec215c4ad99d04d8e44354b6838044b26a6a195b36b86de2ed6012102b2e5b95daf6600d4b210ce5e0a9dae507df9c7b89618c4aea05045e5acc1e7eeffffffff01eceadcd4060000001976a914ea29e13cd4446800297a5883a48caddd6d12377688ac00000000becd09000000000000000000000000".into();
+    let spent_by_tx = vec![
+        UnspentInfo {
+            outpoint: tx.inputs[0].previous_output,
+            value: 100139000,
+            height: Some(642293),
+            script: "2103c9f7c3b8ff78beb991cf806a5c91561cfe68f530c9df2b1402e57621ecbcd6b0ac".into(),
+        },
+        UnspentInfo {
+            outpoint: tx.inputs[1].previous_output,
+            value: 29240917628,
+            height: Some(642293),
+            script: "76a914ea29e13cd4446800297a5883a48caddd6d12377688ac".into(),
+        },
+    ];
+
+    block_on(coin.as_ref().recently_spent_outpoints.lock()).add_spent(
+        spent_by_tx.clone(),
+        tx.hash(),
+        tx.outputs.clone(),
+    );
+    NativeClient::list_unspent
+        .mock_safe(move |_, _, _| MockResult::Return(Box::new(futures01::future::ok(spent_by_tx.clone()))));
+
+    let (unspents_ordered, _) = block_on(coin.get_unspent_ordered_list(&address)).unwrap();
+    // output 0 is spent to self so it must be returned
+    let expected_unspent = UnspentInfo {
+        outpoint: OutPoint {
+            hash: tx.hash(),
+            index: 0,
+        },
+        value: tx.outputs[0].value,
+        height: None,
+        // Should be the same as: Some(output_script.clone()),
+        script: tx.outputs[0].script_pubkey.clone().into(),
     };
     assert_eq!(vec![expected_unspent], unspents_ordered);
 }
@@ -2729,6 +2827,7 @@ fn test_generate_tx_doge_fee() {
         outpoint: Default::default(),
         value: 1000000000000,
         height: None,
+        script: Vec::new().into(),
     }];
     let outputs = vec![TransactionOutput {
         value: 100000000,
@@ -2745,6 +2844,7 @@ fn test_generate_tx_doge_fee() {
         outpoint: Default::default(),
         value: 1000000000000,
         height: None,
+        script: Vec::new().into(),
     }];
     let outputs = vec![
         TransactionOutput {
@@ -2765,6 +2865,7 @@ fn test_generate_tx_doge_fee() {
         outpoint: Default::default(),
         value: 1000000000000,
         height: None,
+        script: Vec::new().into(),
     }];
     let outputs = vec![
         TransactionOutput {
@@ -3063,9 +3164,36 @@ fn tbch_electroncash_verbose_tx_unconfirmed() {
     let _: RpcTransaction = json::from_str(verbose).expect("!json::from_str");
 }
 
+#[test]
+#[cfg(not(target_arch = "wasm32"))]
+fn test_withdraw_to_p2pk_fails() {
+    let client = NativeClient(Arc::new(NativeClientImpl::default()));
+
+    let coin = utxo_coin_for_test(UtxoRpcClientEnum::Native(client), None, false);
+
+    let withdraw_req = WithdrawRequest {
+        amount: 1.into(),
+        from: None,
+        to: "03f8f8fa2062590ba9a0a7a86f937de22f540c015864aad35a2a9f6766de906265".to_string(),
+        coin: TEST_COIN_NAME.into(),
+        max: false,
+        fee: None,
+        memo: None,
+    };
+
+    assert!(matches!(
+        coin.withdraw(withdraw_req).wait().unwrap_err().into_inner(),
+        WithdrawError::InvalidAddress(..)
+    ))
+}
+
 #[test]
 #[cfg(not(target_arch = "wasm32"))]
 fn test_withdraw_to_p2pkh() {
+    let client = NativeClient(Arc::new(NativeClientImpl::default()));
+
+    let coin = utxo_coin_for_test(UtxoRpcClientEnum::Native(client), None, false);
+
     UtxoStandardCoin::get_unspent_ordered_list.mock_safe(|coin, _| {
         let cache = block_on(coin.as_ref().recently_spent_outpoints.lock());
         let unspents = vec![UnspentInfo {
@@ -3075,25 +3203,25 @@ fn test_withdraw_to_p2pkh() {
             },
             value: 1000000000,
             height: Default::default(),
+            script: coin
+                .script_for_address(&block_on(coin.as_ref().derivation_method.unwrap_single_addr()))
+                .unwrap(),
         }];
         MockResult::Return(Box::pin(futures::future::ok((unspents, cache))))
     });
 
-    let client = NativeClient(Arc::new(NativeClientImpl::default()));
-
-    let coin = utxo_coin_for_test(UtxoRpcClientEnum::Native(client), None, false);
-
     // Create a p2pkh address for the test coin
     let p2pkh_address = AddressBuilder::new(
         UtxoAddressFormat::Standard,
-        block_on(coin.as_ref().derivation_method.unwrap_single_addr())
-            .hash()
-            .clone(),
         *block_on(coin.as_ref().derivation_method.unwrap_single_addr()).checksum_type(),
         coin.as_ref().conf.address_prefixes.clone(),
         coin.as_ref().conf.bech32_hrp.clone(),
     )
-    .as_pkh()
+    .as_pkh(
+        block_on(coin.as_ref().derivation_method.unwrap_single_addr())
+            .hash()
+            .clone(),
+    )
     .build()
     .expect("valid address props");
 
@@ -3118,6 +3246,10 @@ fn test_withdraw_to_p2pkh() {
 #[test]
 #[cfg(not(target_arch = "wasm32"))]
 fn test_withdraw_to_p2sh() {
+    let client = NativeClient(Arc::new(NativeClientImpl::default()));
+
+    let coin = utxo_coin_for_test(UtxoRpcClientEnum::Native(client), None, false);
+
     UtxoStandardCoin::get_unspent_ordered_list.mock_safe(|coin, _| {
         let cache = block_on(coin.as_ref().recently_spent_outpoints.lock());
         let unspents = vec![UnspentInfo {
@@ -3127,25 +3259,25 @@ fn test_withdraw_to_p2sh() {
             },
             value: 1000000000,
             height: Default::default(),
+            script: coin
+                .script_for_address(&block_on(coin.as_ref().derivation_method.unwrap_single_addr()))
+                .unwrap(),
         }];
         MockResult::Return(Box::pin(futures::future::ok((unspents, cache))))
     });
 
-    let client = NativeClient(Arc::new(NativeClientImpl::default()));
-
-    let coin = utxo_coin_for_test(UtxoRpcClientEnum::Native(client), None, false);
-
     // Create a p2sh address for the test coin
     let p2sh_address = AddressBuilder::new(
         UtxoAddressFormat::Standard,
-        block_on(coin.as_ref().derivation_method.unwrap_single_addr())
-            .hash()
-            .clone(),
         *block_on(coin.as_ref().derivation_method.unwrap_single_addr()).checksum_type(),
         coin.as_ref().conf.address_prefixes.clone(),
         coin.as_ref().conf.bech32_hrp.clone(),
     )
-    .as_sh()
+    .as_sh(
+        block_on(coin.as_ref().derivation_method.unwrap_single_addr())
+            .hash()
+            .clone(),
+    )
     .build()
     .expect("valid address props");
 
@@ -3170,6 +3302,10 @@ fn test_withdraw_to_p2sh() {
 #[test]
 #[cfg(not(target_arch = "wasm32"))]
 fn test_withdraw_to_p2wpkh() {
+    let client = NativeClient(Arc::new(NativeClientImpl::default()));
+
+    let coin = utxo_coin_for_test(UtxoRpcClientEnum::Native(client), None, true);
+
     UtxoStandardCoin::get_unspent_ordered_list.mock_safe(|coin, _| {
         let cache = block_on(coin.as_ref().recently_spent_outpoints.lock());
         let unspents = vec![UnspentInfo {
@@ -3179,25 +3315,25 @@ fn test_withdraw_to_p2wpkh() {
             },
             value: 1000000000,
             height: Default::default(),
+            script: coin
+                .script_for_address(&block_on(coin.as_ref().derivation_method.unwrap_single_addr()))
+                .unwrap(),
         }];
         MockResult::Return(Box::pin(futures::future::ok((unspents, cache))))
     });
 
-    let client = NativeClient(Arc::new(NativeClientImpl::default()));
-
-    let coin = utxo_coin_for_test(UtxoRpcClientEnum::Native(client), None, true);
-
     // Create a p2wpkh address for the test coin
     let p2wpkh_address = AddressBuilder::new(
         UtxoAddressFormat::Segwit,
-        block_on(coin.as_ref().derivation_method.unwrap_single_addr())
-            .hash()
-            .clone(),
         *block_on(coin.as_ref().derivation_method.unwrap_single_addr()).checksum_type(),
         NetworkAddressPrefixes::default(),
         coin.as_ref().conf.bech32_hrp.clone(),
     )
-    .as_pkh()
+    .as_pkh(
+        block_on(coin.as_ref().derivation_method.unwrap_single_addr())
+            .hash()
+            .clone(),
+    )
     .build()
     .expect("valid address props");
 
@@ -3219,6 +3355,56 @@ fn test_withdraw_to_p2wpkh() {
     assert_eq!(output_script, expected_script);
 }
 
+#[test]
+#[cfg(not(target_arch = "wasm32"))]
+fn test_withdraw_p2pk_balance() {
+    let client = NativeClient(Arc::new(NativeClientImpl::default()));
+
+    let coin = utxo_coin_for_test(UtxoRpcClientEnum::Native(client), None, false);
+
+    UtxoStandardCoin::get_unspent_ordered_list.mock_safe(|coin, _| {
+        let cache = block_on(coin.as_ref().recently_spent_outpoints.lock());
+        let unspents = vec![UnspentInfo {
+            outpoint: OutPoint {
+                hash: 1.into(),
+                index: 0,
+            },
+            value: 1000000000,
+            height: Default::default(),
+            // Use a p2pk output script for this UTXO
+            script: output_script_p2pk(
+                &block_on(coin.as_ref().derivation_method.unwrap_single_addr())
+                    .pubkey()
+                    .unwrap(),
+            ),
+        }];
+        MockResult::Return(Box::pin(futures::future::ok((unspents, cache))))
+    });
+
+    // Create a dummy p2pkh address to withdraw the coins to.
+    let my_p2pkh_address = block_on(coin.as_ref().derivation_method.unwrap_single_addr());
+
+    let withdraw_req = WithdrawRequest {
+        amount: 1.into(),
+        from: None,
+        to: my_p2pkh_address.to_string(),
+        coin: TEST_COIN_NAME.into(),
+        max: false,
+        fee: None,
+        memo: None,
+    };
+    let tx_details = coin.withdraw(withdraw_req).wait().unwrap();
+    let transaction: UtxoTx = deserialize(tx_details.tx_hex.as_slice()).unwrap();
+
+    // The change should be in a p2pkh script.
+    let output_script: Script = transaction.outputs[1].script_pubkey.clone().into();
+    let expected_script = Builder::build_p2pkh(my_p2pkh_address.hash());
+    assert_eq!(output_script, expected_script);
+
+    // And it should have this value (p2pk balance - amount sent - fees).
+    assert_eq!(transaction.outputs[1].value, 899999000);
+}
+
 /// `UtxoStandardCoin` has to check UTXO maturity if `check_utxo_maturity` is `true`.
 /// https://github.com/KomodoPlatform/atomicDEX-API/issues/1181
 #[test]
@@ -3385,15 +3571,7 @@ fn test_split_qtum() {
         UtxoAddressFormat::Segwit => SignatureVersion::WitnessV0,
         _ => coin.as_ref().conf.signature_version,
     };
-    let prev_script = output_script(&p2pkh_address).expect("valid previous script must be built");
-    let signed = sign_tx(
-        unsigned,
-        key_pair,
-        prev_script,
-        signature_version,
-        coin.as_ref().conf.fork_id,
-    )
-    .unwrap();
+    let signed = sign_tx(unsigned, key_pair, signature_version, coin.as_ref().conf.fork_id).unwrap();
     log!("Signed tx = {:?}", signed);
     let res = block_on(coin.broadcast_tx(&signed)).unwrap();
     log!("Res = {:?}", res);
diff --git a/mm2src/coins/utxo/utxo_withdraw.rs b/mm2src/coins/utxo/utxo_withdraw.rs
index 41350a1be2..279b759d58 100644
--- a/mm2src/coins/utxo/utxo_withdraw.rs
+++ b/mm2src/coins/utxo/utxo_withdraw.rs
@@ -17,7 +17,7 @@ use mm2_core::mm_ctx::MmArc;
 use mm2_err_handle::prelude::*;
 use rpc::v1::types::ToTxHash;
 use rpc_task::RpcTaskError;
-use script::{Builder, Script, SignatureVersion, TransactionInputSigner};
+use script::{SignatureVersion, TransactionInputSigner};
 use serialization::{serialize, serialize_with_flags, SERIALIZE_TRANSACTION_WITNESS};
 use std::iter::once;
 use std::sync::Arc;
@@ -114,19 +114,6 @@ where
         }
     }
 
-    #[allow(clippy::result_large_err)]
-    fn prev_script(&self) -> Result<Script, MmError<WithdrawError>> {
-        match self.sender_address().addr_format() {
-            UtxoAddressFormat::Segwit => match Builder::build_p2wpkh(self.sender_address().hash()) {
-                Ok(script) => Ok(script),
-                Err(e) => MmError::err(WithdrawError::InternalError(e.to_string())),
-            },
-            UtxoAddressFormat::Standard | UtxoAddressFormat::CashAddress { .. } => {
-                Ok(Builder::build_p2pkh(self.sender_address().hash()))
-            },
-        }
-    }
-
     #[allow(clippy::result_large_err)]
     fn on_generating_transaction(&self) -> Result<(), MmError<WithdrawError>>;
 
@@ -323,8 +310,7 @@ where
 
         sign_params
             .with_signature_version(self.signature_version())
-            .with_unsigned_tx(unsigned_tx)
-            .with_prev_script(self.coin.script_for_address(&self.from_address)?);
+            .with_unsigned_tx(unsigned_tx);
         let sign_params = sign_params.build()?;
 
         let crypto_ctx = CryptoCtx::from_ctx(&self.ctx)?;
@@ -433,7 +419,6 @@ where
         Ok(with_key_pair::sign_tx(
             unsigned_tx,
             &self.key_pair,
-            self.prev_script()?,
             self.signature_version(),
             self.coin.as_ref().conf.fork_id,
         )?)
diff --git a/mm2src/coins/utxo_signer/src/lib.rs b/mm2src/coins/utxo_signer/src/lib.rs
index 9285bf8587..8032e9acf7 100644
--- a/mm2src/coins/utxo_signer/src/lib.rs
+++ b/mm2src/coins/utxo_signer/src/lib.rs
@@ -55,6 +55,11 @@ pub enum UtxoSignTxError {
         script: Script,
         prev_script: Script,
     },
+    #[display(
+        fmt = "Can't spend the UTXO with script = '{}'. This script format isn't supported",
+        script
+    )]
+    UnspendableUTXO { script: Script },
     #[display(fmt = "Transport error: {}", _0)]
     Transport(String),
     #[display(fmt = "Internal error: {}", _0)]
@@ -82,6 +87,7 @@ impl From<UtxoSignWithKeyPairError> for UtxoSignTxError {
             // that are expected to be checked by [`sign_common::UtxoSignTxParamsBuilder::build`] already.
             // So if this error happens, it's our internal error.
             UtxoSignWithKeyPairError::InputIndexOutOfBound { .. } => UtxoSignTxError::Internal(error),
+            UtxoSignWithKeyPairError::UnspendableUTXO { script } => UtxoSignTxError::UnspendableUTXO { script },
             UtxoSignWithKeyPairError::ErrorSigning(sign) => UtxoSignTxError::ErrorSigning(sign),
         }
     }
@@ -140,13 +146,8 @@ pub trait UtxoSignerOps {
                 signer.sign_tx().await
             },
             SignPolicy::WithKeyPair(key_pair) => {
-                let signed = with_key_pair::sign_tx(
-                    params.unsigned_tx,
-                    key_pair,
-                    params.prev_script,
-                    params.signature_version,
-                    self.fork_id(),
-                )?;
+                let signed =
+                    with_key_pair::sign_tx(params.unsigned_tx, key_pair, params.signature_version, self.fork_id())?;
                 Ok(signed)
             },
         }
diff --git a/mm2src/coins/utxo_signer/src/sign_params.rs b/mm2src/coins/utxo_signer/src/sign_params.rs
index e66d504eb2..c43ed040ef 100644
--- a/mm2src/coins/utxo_signer/src/sign_params.rs
+++ b/mm2src/coins/utxo_signer/src/sign_params.rs
@@ -4,7 +4,7 @@ use crypto::trezor::utxo::TrezorOutputScriptType;
 use crypto::DerivationPath;
 use keys::{AddressFormat, Public as PublicKey};
 use mm2_err_handle::prelude::*;
-use script::{Script, SignatureVersion, TransactionInputSigner, UnsignedTransactionInput};
+use script::{SignatureVersion, TransactionInputSigner, UnsignedTransactionInput};
 
 impl UtxoSignTxError {
     fn no_param(param: &str) -> UtxoSignTxError {
@@ -77,8 +77,6 @@ pub struct UtxoSignTxParamsBuilder {
     inputs_infos: Vec<SpendingInputInfo>,
     /// The number of elements is expected to be the same as `unsigned_tx.outputs.len()`.
     outputs_infos: Vec<SendingOutputInfo>,
-    /// This is used to check if a built from key pair matches the expected `prev_script`.
-    prev_script: Option<Script>,
 }
 
 impl Default for UtxoSignTxParamsBuilder {
@@ -92,7 +90,6 @@ impl UtxoSignTxParamsBuilder {
             unsigned_tx: None,
             inputs_infos: Vec::new(),
             outputs_infos: Vec::new(),
-            prev_script: None,
         }
     }
 
@@ -122,11 +119,6 @@ impl UtxoSignTxParamsBuilder {
         self
     }
 
-    pub fn with_prev_script(&mut self, prev_script: Script) -> &mut UtxoSignTxParamsBuilder {
-        self.prev_script = Some(prev_script);
-        self
-    }
-
     pub fn build(self) -> UtxoSignTxResult<UtxoSignTxParams> {
         let unsigned_tx = self
             .unsigned_tx
@@ -159,9 +151,6 @@ impl UtxoSignTxParamsBuilder {
             unsigned_tx,
             inputs_infos: self.inputs_infos,
             outputs_infos: self.outputs_infos,
-            prev_script: self
-                .prev_script
-                .or_mm_err(|| UtxoSignTxError::no_param("prev_script"))?,
         };
         Ok(params)
     }
@@ -174,8 +163,6 @@ pub struct UtxoSignTxParams {
     pub(crate) inputs_infos: Vec<SpendingInputInfo>,
     /// The number of elements is exactly the same as `unsigned_tx.outputs.len()`.
     pub(crate) outputs_infos: Vec<SendingOutputInfo>,
-    /// This is used to check if a built from key pair matches the expected `prev_script`.
-    pub(crate) prev_script: Script,
 }
 
 impl UtxoSignTxParams {
diff --git a/mm2src/coins/utxo_signer/src/with_key_pair.rs b/mm2src/coins/utxo_signer/src/with_key_pair.rs
index 151884a05e..8d67e23f9c 100644
--- a/mm2src/coins/utxo_signer/src/with_key_pair.rs
+++ b/mm2src/coins/utxo_signer/src/with_key_pair.rs
@@ -7,7 +7,7 @@ use keys::bytes::Bytes;
 use keys::KeyPair;
 use mm2_err_handle::prelude::*;
 use primitives::hash::H256;
-use script::{Builder, Script, SignatureVersion, TransactionInputSigner, UnsignedTransactionInput};
+use script::{Builder, Script, ScriptType, SignatureVersion, TransactionInputSigner, UnsignedTransactionInput};
 
 pub const SIGHASH_ALL: u32 = 1;
 pub const _SIGHASH_NONE: u32 = 2;
@@ -30,6 +30,11 @@ pub enum UtxoSignWithKeyPairError {
     },
     #[display(fmt = "Input index '{}' is out of bound. Total length = {}", index, len)]
     InputIndexOutOfBound { len: usize, index: usize },
+    #[display(
+        fmt = "Can't spend the UTXO with script = '{}'. This script format isn't supported",
+        script
+    )]
+    UnspendableUTXO { script: Script },
     #[display(fmt = "Error signing using a private key")]
     ErrorSigning(keys::Error),
 }
@@ -41,37 +46,25 @@ impl From<keys::Error> for UtxoSignWithKeyPairError {
 pub fn sign_tx(
     unsigned: TransactionInputSigner,
     key_pair: &KeyPair,
-    prev_script: Script,
     signature_version: SignatureVersion,
     fork_id: u32,
 ) -> UtxoSignWithKeyPairResult<UtxoTx> {
-    let mut signed_inputs = Vec::with_capacity(unsigned.inputs.len());
-    match signature_version {
-        SignatureVersion::WitnessV0 => {
-            for (i, _) in unsigned.inputs.iter().enumerate() {
-                signed_inputs.push(p2wpkh_spend(
-                    &unsigned,
-                    i,
-                    key_pair,
-                    prev_script.clone(),
-                    signature_version,
-                    fork_id,
-                )?);
-            }
-        },
-        _ => {
-            for (i, _) in unsigned.inputs.iter().enumerate() {
-                signed_inputs.push(p2pkh_spend(
-                    &unsigned,
-                    i,
-                    key_pair,
-                    prev_script.clone(),
-                    signature_version,
-                    fork_id,
-                )?);
+    let signed_inputs = unsigned
+        .inputs
+        .iter()
+        .enumerate()
+        .map(|(i, input)| {
+            match input.prev_script.script_type() {
+                ScriptType::WitnessKey => p2wpkh_spend(&unsigned, i, key_pair, SignatureVersion::WitnessV0, fork_id),
+                ScriptType::PubKeyHash => p2pkh_spend(&unsigned, i, key_pair, signature_version, fork_id),
+                // Allow spending legacy P2PK utxos.
+                ScriptType::PubKey => p2pk_spend(&unsigned, i, key_pair, signature_version, fork_id),
+                _ => MmError::err(UtxoSignWithKeyPairError::UnspendableUTXO {
+                    script: input.prev_script.clone(),
+                }),
             }
-        },
-    }
+        })
+        .collect::<UtxoSignWithKeyPairResult<_>>()?;
     Ok(complete_tx(unsigned, signed_inputs))
 }
 
@@ -86,6 +79,14 @@ pub fn p2pk_spend(
     let unsigned_input = get_input(signer, input_index)?;
 
     let script = Builder::build_p2pk(key_pair.public());
+    if script != unsigned_input.prev_script {
+        return MmError::err(UtxoSignWithKeyPairError::MismatchScript {
+            script_type: "P2PK".to_owned(),
+            script,
+            prev_script: unsigned_input.prev_script.clone(),
+        });
+    }
+
     let signature = calc_and_sign_sighash(
         signer,
         input_index,
@@ -103,18 +104,17 @@ pub fn p2pkh_spend(
     signer: &TransactionInputSigner,
     input_index: usize,
     key_pair: &KeyPair,
-    prev_script: Script,
     signature_version: SignatureVersion,
     fork_id: u32,
 ) -> UtxoSignWithKeyPairResult<TransactionInput> {
     let unsigned_input = get_input(signer, input_index)?;
 
     let script = Builder::build_p2pkh(&key_pair.public().address_hash().into());
-    if script != prev_script {
+    if script != unsigned_input.prev_script {
         return MmError::err(UtxoSignWithKeyPairError::MismatchScript {
             script_type: "P2PKH".to_owned(),
             script,
-            prev_script,
+            prev_script: unsigned_input.prev_script.clone(),
         });
     }
 
@@ -170,7 +170,6 @@ pub fn p2wpkh_spend(
     signer: &TransactionInputSigner,
     input_index: usize,
     key_pair: &KeyPair,
-    prev_script: Script,
     signature_version: SignatureVersion,
     fork_id: u32,
 ) -> UtxoSignWithKeyPairResult<TransactionInput> {
@@ -178,11 +177,11 @@ pub fn p2wpkh_spend(
 
     let script_code = Builder::build_p2pkh(&key_pair.public().address_hash().into()); // this is the scriptCode by BIP-0143: for P2WPKH scriptCode is P2PKH
     let script_pub_key = Builder::build_p2wpkh(&key_pair.public().address_hash().into())?;
-    if script_pub_key != prev_script {
+    if script_pub_key != unsigned_input.prev_script {
         return MmError::err(UtxoSignWithKeyPairError::MismatchScript {
             script_type: "P2WPKH".to_owned(),
             script: script_pub_key,
-            prev_script,
+            prev_script: unsigned_input.prev_script.clone(),
         });
     }
 
diff --git a/mm2src/coins/z_coin/z_htlc.rs b/mm2src/coins/z_coin/z_htlc.rs
index 0f7d9fba6f..c2fba37a88 100644
--- a/mm2src/coins/z_coin/z_htlc.rs
+++ b/mm2src/coins/z_coin/z_htlc.rs
@@ -48,12 +48,11 @@ pub async fn z_send_htlc(
     let script_hash = dhash160(&payment_script);
     let htlc_address = AddressBuilder::new(
         UtxoAddressFormat::Standard,
-        script_hash.into(),
         coin.utxo_arc.conf.checksum_type,
         coin.utxo_arc.conf.address_prefixes.clone(),
         None,
     )
-    .as_sh()
+    .as_sh(script_hash.into())
     .build()
     .map_to_mm(SendOutputsErr::InternalError)?;
 
diff --git a/mm2src/crypto/src/privkey.rs b/mm2src/crypto/src/privkey.rs
index 620b214955..d86a0e930f 100644
--- a/mm2src/crypto/src/privkey.rs
+++ b/mm2src/crypto/src/privkey.rs
@@ -1,5 +1,5 @@
 /******************************************************************************
- * Copyright © 2023 Pampex LTD and TillyHK LTD              *
+ * Copyright © 2023 Pampex LTD and TillyHK LTD                                *
  *                                                                            *
  * See the CONTRIBUTOR-LICENSE-AGREEMENT, COPYING, LICENSE-COPYRIGHT-NOTICE   *
  * and DEVELOPER-CERTIFICATE-OF-ORIGIN files in the LEGAL directory in        *
diff --git a/mm2src/mm2_bitcoin/keys/src/address.rs b/mm2src/mm2_bitcoin/keys/src/address.rs
index ed30b78aef..61d262245d 100644
--- a/mm2src/mm2_bitcoin/keys/src/address.rs
+++ b/mm2src/mm2_bitcoin/keys/src/address.rs
@@ -5,11 +5,13 @@
 //!
 //! https://en.bitcoin.it/wiki/Address
 
+use crate::Public;
 use crypto::{dgroestl512, dhash256, keccak256, ChecksumType};
 use derive_more::Display;
 use serde::{Deserialize, Serialize};
-use std::fmt;
 use std::str::FromStr;
+use std::{fmt, hash::Hash};
+
 use {AddressHashEnum, AddressPrefix, CashAddrType, CashAddress, Error, LegacyAddress, NetworkAddressPrefixes,
      SegwitAddress};
 
@@ -97,13 +99,15 @@ pub fn detect_checksum(data: &[u8], checksum: &[u8]) -> Result<ChecksumType, Err
 /// Struct for utxo address types representation
 /// Contains address hash, format, prefix to get as a string.
 /// Also has output ScriptType field to create output script.
-#[derive(Clone, Debug, Eq, Hash, PartialEq)]
+#[derive(Clone, Debug, Eq)]
 pub struct Address {
     /// The base58 prefix of the address.
     prefix: AddressPrefix,
     /// Segwit addr human readable part
     hrp: Option<String>,
-    /// Public key hash.
+    /// The public key of the address.
+    pubkey: Option<Public>,
+    /// Public key/Script hash.
     hash: AddressHashEnum,
     /// Checksum type
     checksum_type: ChecksumType,
@@ -113,9 +117,36 @@ pub struct Address {
     script_type: AddressScriptType,
 }
 
+impl PartialEq for Address {
+    /// A `PartialEq` implementation that doesn't take `pubkey` into consideration. That's because
+    /// we want to rely on address `hash` only for knowing whether two addresses are equal since `pubkey`
+    /// might not always be available.
+    fn eq(&self, other: &Self) -> bool {
+        self.prefix == other.prefix
+            && self.hrp == other.hrp
+            && self.hash == other.hash
+            && self.checksum_type == other.checksum_type
+            && self.addr_format == other.addr_format
+            && self.script_type == other.script_type
+    }
+}
+
+impl Hash for Address {
+    /// Like the `PartialEq` implementation, this `Hash` implementation doesn't take `pubkey` into consideration.
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.prefix.hash(state);
+        self.hrp.hash(state);
+        self.hash.hash(state);
+        self.checksum_type.hash(state);
+        self.addr_format.hash(state);
+        self.script_type.hash(state);
+    }
+}
+
 impl Address {
     pub fn prefix(&self) -> &AddressPrefix { &self.prefix }
     pub fn hrp(&self) -> &Option<String> { &self.hrp }
+    pub fn pubkey(&self) -> &Option<Public> { &self.pubkey }
     pub fn hash(&self) -> &AddressHashEnum { &self.hash }
     pub fn checksum_type(&self) -> &ChecksumType { &self.checksum_type }
     pub fn addr_format(&self) -> &AddressFormat { &self.addr_format }
@@ -173,6 +204,7 @@ impl Address {
             hash,
             checksum_type: address.checksum_type,
             hrp: None,
+            pubkey: None,
             addr_format: AddressFormat::Standard,
             script_type,
         })
@@ -202,6 +234,7 @@ impl Address {
             hash,
             checksum_type,
             hrp: None,
+            pubkey: None,
             addr_format: AddressFormat::CashAddress {
                 network: address.prefix.to_string(),
                 pub_addr_prefix: net_addr_prefixes.p2pkh.get_size_1_prefix(),
@@ -248,6 +281,7 @@ impl Address {
             hash,
             checksum_type,
             hrp,
+            pubkey: None,
             addr_format: AddressFormat::Segwit,
             script_type,
         })
@@ -295,12 +329,13 @@ mod tests {
     fn test_address_to_string() {
         let address = AddressBuilder::new(
             AddressFormat::Standard,
-            AddressHashEnum::AddressHash("3f4aa1fedf1f54eeb03b759deadb36676b184911".into()),
             ChecksumType::DSHA256,
             (*BTC_PREFIXES).clone(),
             None,
         )
-        .as_pkh()
+        .as_pkh(AddressHashEnum::AddressHash(
+            "3f4aa1fedf1f54eeb03b759deadb36676b184911".into(),
+        ))
         .build()
         .expect("valid address props");
 
@@ -311,12 +346,13 @@ mod tests {
     fn test_komodo_address_to_string() {
         let address = AddressBuilder::new(
             AddressFormat::Standard,
-            AddressHashEnum::AddressHash("05aab5342166f8594baf17a7d9bef5d567443327".into()),
             ChecksumType::DSHA256,
             (*KMD_PREFIXES).clone(),
             None,
         )
-        .as_pkh()
+        .as_pkh(AddressHashEnum::AddressHash(
+            "05aab5342166f8594baf17a7d9bef5d567443327".into(),
+        ))
         .build()
         .expect("valid address props");
 
@@ -327,12 +363,13 @@ mod tests {
     fn test_zec_t_address_to_string() {
         let address = AddressBuilder::new(
             AddressFormat::Standard,
-            AddressHashEnum::AddressHash("05aab5342166f8594baf17a7d9bef5d567443327".into()),
             ChecksumType::DSHA256,
             (*T_ZCASH_PREFIXES).clone(),
             None,
         )
-        .as_pkh()
+        .as_pkh(AddressHashEnum::AddressHash(
+            "05aab5342166f8594baf17a7d9bef5d567443327".into(),
+        ))
         .build()
         .expect("valid address props");
 
@@ -343,12 +380,13 @@ mod tests {
     fn test_komodo_p2sh_address_to_string() {
         let address = AddressBuilder::new(
             AddressFormat::Standard,
-            AddressHashEnum::AddressHash("ca0c3786c96ff7dacd40fdb0f7c196528df35f85".into()),
             ChecksumType::DSHA256,
             (*KMD_PREFIXES).clone(),
             None,
         )
-        .as_sh()
+        .as_sh(AddressHashEnum::AddressHash(
+            "ca0c3786c96ff7dacd40fdb0f7c196528df35f85".into(),
+        ))
         .build()
         .expect("valid address props"); // TODO: check with P2PKH
 
@@ -359,12 +397,13 @@ mod tests {
     fn test_address_from_str() {
         let address = AddressBuilder::new(
             AddressFormat::Standard,
-            AddressHashEnum::AddressHash("3f4aa1fedf1f54eeb03b759deadb36676b184911".into()),
             ChecksumType::DSHA256,
             (*BTC_PREFIXES).clone(),
             None,
         )
-        .as_pkh()
+        .as_pkh(AddressHashEnum::AddressHash(
+            "3f4aa1fedf1f54eeb03b759deadb36676b184911".into(),
+        ))
         .build()
         .expect("valid address props");
 
@@ -379,12 +418,13 @@ mod tests {
     fn test_komodo_address_from_str() {
         let address = AddressBuilder::new(
             AddressFormat::Standard,
-            AddressHashEnum::AddressHash("05aab5342166f8594baf17a7d9bef5d567443327".into()),
             ChecksumType::DSHA256,
             (*KMD_PREFIXES).clone(),
             None,
         )
-        .as_pkh()
+        .as_pkh(AddressHashEnum::AddressHash(
+            "05aab5342166f8594baf17a7d9bef5d567443327".into(),
+        ))
         .build()
         .expect("valid address props");
 
@@ -399,12 +439,13 @@ mod tests {
     fn test_zec_address_from_str() {
         let address = AddressBuilder::new(
             AddressFormat::Standard,
-            AddressHashEnum::AddressHash("05aab5342166f8594baf17a7d9bef5d567443327".into()),
             ChecksumType::DSHA256,
             (*T_ZCASH_PREFIXES).clone(),
             None,
         )
-        .as_pkh()
+        .as_pkh(AddressHashEnum::AddressHash(
+            "05aab5342166f8594baf17a7d9bef5d567443327".into(),
+        ))
         .build()
         .expect("valid address props");
 
@@ -419,12 +460,13 @@ mod tests {
     fn test_komodo_p2sh_address_from_str() {
         let address = AddressBuilder::new(
             AddressFormat::Standard,
-            AddressHashEnum::AddressHash("ca0c3786c96ff7dacd40fdb0f7c196528df35f85".into()),
             ChecksumType::DSHA256,
             (*KMD_PREFIXES).clone(),
             None,
         )
-        .as_sh()
+        .as_sh(AddressHashEnum::AddressHash(
+            "ca0c3786c96ff7dacd40fdb0f7c196528df35f85".into(),
+        ))
         .build()
         .expect("valid address props");
 
@@ -439,12 +481,13 @@ mod tests {
     fn test_grs_addr_from_str() {
         let address = AddressBuilder::new(
             AddressFormat::Standard,
-            AddressHashEnum::AddressHash("c3f710deb7320b0efa6edb14e3ebeeb9155fa90d".into()),
             ChecksumType::DGROESTL512,
             (*GRS_PREFIXES).clone(),
             None,
         )
-        .as_pkh()
+        .as_pkh(AddressHashEnum::AddressHash(
+            "c3f710deb7320b0efa6edb14e3ebeeb9155fa90d".into(),
+        ))
         .build()
         .expect("valid address props");
 
@@ -459,12 +502,13 @@ mod tests {
     fn test_smart_addr_from_str() {
         let address = AddressBuilder::new(
             AddressFormat::Standard,
-            AddressHashEnum::AddressHash("56bb05aa20f5a80cf84e90e5dab05be331333e27".into()),
             ChecksumType::KECCAK256,
             (*SYS_PREFIXES).clone(),
             None,
         )
-        .as_pkh()
+        .as_pkh(AddressHashEnum::AddressHash(
+            "56bb05aa20f5a80cf84e90e5dab05be331333e27".into(),
+        ))
         .build()
         .expect("valid address props");
 
@@ -528,17 +572,16 @@ mod tests {
                 pub_addr_prefix: 0,
                 p2sh_addr_prefix: 5,
             },
-            AddressHashEnum::AddressHash(
-                [
-                    140, 0, 44, 191, 189, 83, 144, 173, 47, 216, 127, 59, 80, 232, 159, 100, 156, 132, 78, 192,
-                ]
-                .into(),
-            ),
             ChecksumType::DSHA256,
             unknown_prefixes,
             None,
         )
-        .as_sh()
+        .as_sh(AddressHashEnum::AddressHash(
+            [
+                140, 0, 44, 191, 189, 83, 144, 173, 47, 216, 127, 59, 80, 232, 159, 100, 156, 132, 78, 192,
+            ]
+            .into(),
+        ))
         .build()
         .expect("valid address props"); // actually prefix == 2 is unknown and is neither P2PKH nor P2SH
 
diff --git a/mm2src/mm2_bitcoin/keys/src/address/address_builder.rs b/mm2src/mm2_bitcoin/keys/src/address/address_builder.rs
index c292f72510..84e08a5e9b 100644
--- a/mm2src/mm2_bitcoin/keys/src/address/address_builder.rs
+++ b/mm2src/mm2_bitcoin/keys/src/address/address_builder.rs
@@ -1,13 +1,17 @@
+use crate::Public;
 use crypto::ChecksumType;
+
 use {Address, AddressFormat, AddressHashEnum, AddressPrefix, AddressScriptType, NetworkAddressPrefixes};
 
 /// Params for AddressBuilder to select output script type
 #[derive(PartialEq)]
 pub enum AddressBuilderOption {
     /// build for pay to pubkey hash output (witness or legacy)
-    BuildAsPubkeyHash,
+    PubkeyHash(AddressHashEnum),
     /// build for pay to script hash output (witness or legacy)
-    BuildAsScriptHash,
+    ScriptHash(AddressHashEnum),
+    /// build for pay to pubkey hash but using a public key as an input (not pubkey hash)
+    FromPubKey(Public),
 }
 
 /// Builds Address struct depending on addr_format, validates params to build Address
@@ -16,8 +20,6 @@ pub struct AddressBuilder {
     prefixes: NetworkAddressPrefixes,
     /// Segwit addr human readable part
     hrp: Option<String>,
-    /// Public key hash
-    hash: AddressHashEnum,
     /// Checksum type
     checksum_type: ChecksumType,
     /// Address Format
@@ -29,14 +31,12 @@ pub struct AddressBuilder {
 impl AddressBuilder {
     pub fn new(
         addr_format: AddressFormat,
-        hash: AddressHashEnum,
         checksum_type: ChecksumType,
         prefixes: NetworkAddressPrefixes,
         hrp: Option<String>,
     ) -> Self {
         Self {
             addr_format,
-            hash,
             checksum_type,
             prefixes,
             hrp,
@@ -50,15 +50,21 @@ impl AddressBuilder {
         self
     }
 
+    /// Sets Address tx output script type as p2pkh or p2wpkh, but also keep the public key stored.
+    pub fn as_pkh_from_pk(mut self, pubkey: Public) -> Self {
+        self.build_option = Some(AddressBuilderOption::FromPubKey(pubkey));
+        self
+    }
+
     /// Sets Address tx output script type as p2pkh or p2wpkh
-    pub fn as_pkh(mut self) -> Self {
-        self.build_option = Some(AddressBuilderOption::BuildAsPubkeyHash);
+    pub fn as_pkh(mut self, hash: AddressHashEnum) -> Self {
+        self.build_option = Some(AddressBuilderOption::PubkeyHash(hash));
         self
     }
 
     /// Sets Address tx output script type as p2sh or p2wsh
-    pub fn as_sh(mut self) -> Self {
-        self.build_option = Some(AddressBuilderOption::BuildAsScriptHash);
+    pub fn as_sh(mut self, hash: AddressHashEnum) -> Self {
+        self.build_option = Some(AddressBuilderOption::ScriptHash(hash));
         self
     }
 
@@ -68,7 +74,8 @@ impl AddressBuilder {
             AddressFormat::Standard => Ok(Address {
                 prefix: self.get_address_prefix(build_option)?,
                 hrp: None,
-                hash: self.hash.clone(),
+                hash: self.get_hash(build_option),
+                pubkey: self.get_pubkey(build_option),
                 checksum_type: self.checksum_type,
                 addr_format: self.addr_format.clone(),
                 script_type: self.get_legacy_script_type(build_option),
@@ -79,7 +86,8 @@ impl AddressBuilder {
                 Ok(Address {
                     prefix: AddressPrefix::default(),
                     hrp: self.hrp.clone(),
-                    hash: self.hash.clone(),
+                    hash: self.get_hash(build_option),
+                    pubkey: self.get_pubkey(build_option),
                     checksum_type: self.checksum_type,
                     addr_format: self.addr_format.clone(),
                     script_type: self.get_segwit_script_type(build_option),
@@ -88,7 +96,8 @@ impl AddressBuilder {
             AddressFormat::CashAddress { .. } => Ok(Address {
                 prefix: self.get_address_prefix(build_option)?,
                 hrp: None,
-                hash: self.hash.clone(),
+                hash: self.get_hash(build_option),
+                pubkey: self.get_pubkey(build_option),
                 checksum_type: self.checksum_type,
                 addr_format: self.addr_format.clone(),
                 script_type: self.get_legacy_script_type(build_option),
@@ -98,8 +107,8 @@ impl AddressBuilder {
 
     fn get_address_prefix(&self, build_option: &AddressBuilderOption) -> Result<AddressPrefix, String> {
         let prefix = match build_option {
-            AddressBuilderOption::BuildAsPubkeyHash => &self.prefixes.p2pkh,
-            AddressBuilderOption::BuildAsScriptHash => &self.prefixes.p2sh,
+            AddressBuilderOption::PubkeyHash(_) | AddressBuilderOption::FromPubKey(_) => &self.prefixes.p2pkh,
+            AddressBuilderOption::ScriptHash(_) => &self.prefixes.p2sh,
         };
         if prefix.is_empty() {
             return Err("no prefix for address set".to_owned());
@@ -109,15 +118,30 @@ impl AddressBuilder {
 
     fn get_legacy_script_type(&self, build_option: &AddressBuilderOption) -> AddressScriptType {
         match build_option {
-            AddressBuilderOption::BuildAsPubkeyHash => AddressScriptType::P2PKH,
-            AddressBuilderOption::BuildAsScriptHash => AddressScriptType::P2SH,
+            AddressBuilderOption::PubkeyHash(_) | AddressBuilderOption::FromPubKey(_) => AddressScriptType::P2PKH,
+            AddressBuilderOption::ScriptHash(_) => AddressScriptType::P2SH,
         }
     }
 
     fn get_segwit_script_type(&self, build_option: &AddressBuilderOption) -> AddressScriptType {
         match build_option {
-            AddressBuilderOption::BuildAsPubkeyHash => AddressScriptType::P2WPKH,
-            AddressBuilderOption::BuildAsScriptHash => AddressScriptType::P2WSH,
+            AddressBuilderOption::PubkeyHash(_) | AddressBuilderOption::FromPubKey(_) => AddressScriptType::P2WPKH,
+            AddressBuilderOption::ScriptHash(_) => AddressScriptType::P2WSH,
+        }
+    }
+
+    fn get_hash(&self, build_option: &AddressBuilderOption) -> AddressHashEnum {
+        match build_option {
+            AddressBuilderOption::PubkeyHash(hash) => hash.clone(),
+            AddressBuilderOption::ScriptHash(hash) => hash.clone(),
+            AddressBuilderOption::FromPubKey(pubkey) => AddressHashEnum::AddressHash(pubkey.address_hash()),
+        }
+    }
+
+    fn get_pubkey(&self, build_option: &AddressBuilderOption) -> Option<Public> {
+        match build_option {
+            AddressBuilderOption::FromPubKey(pubkey) => Some(*pubkey),
+            _ => None,
         }
     }
 
@@ -130,8 +154,9 @@ impl AddressBuilder {
 
     fn check_segwit_hash(&self, build_option: &AddressBuilderOption) -> Result<(), String> {
         let is_hash_valid = match build_option {
-            AddressBuilderOption::BuildAsPubkeyHash => self.hash.is_address_hash(),
-            AddressBuilderOption::BuildAsScriptHash => self.hash.is_witness_script_hash(),
+            AddressBuilderOption::PubkeyHash(hash) => hash.is_address_hash(),
+            AddressBuilderOption::ScriptHash(hash) => hash.is_witness_script_hash(),
+            AddressBuilderOption::FromPubKey(_) => true,
         };
         if !is_hash_valid {
             return Err("invalid hash for segwit address".to_owned());
diff --git a/mm2src/mm2_bitcoin/keys/src/lib.rs b/mm2src/mm2_bitcoin/keys/src/lib.rs
index c7d28687b9..d3a01d854d 100644
--- a/mm2src/mm2_bitcoin/keys/src/lib.rs
+++ b/mm2src/mm2_bitcoin/keys/src/lib.rs
@@ -52,7 +52,7 @@ pub type Message = H256;
 
 #[derive(Clone, Debug, Eq, Hash, PartialEq)]
 pub enum AddressHashEnum {
-    /// 20 bytes long hash derived from public `ripemd160(sha256(public))` used in P2PKH, P2SH, P2WPKH
+    /// 20 bytes long hash derived from public `ripemd160(sha256(public/script))` used in P2PKH, P2SH, P2WPKH
     AddressHash(H160),
     /// 32 bytes long hash derived from script `sha256(script)` used in P2WSH
     WitnessScriptHash(H256),
diff --git a/mm2src/mm2_bitcoin/keys/src/public.rs b/mm2src/mm2_bitcoin/keys/src/public.rs
index b57f376ee9..cb801585d8 100644
--- a/mm2src/mm2_bitcoin/keys/src/public.rs
+++ b/mm2src/mm2_bitcoin/keys/src/public.rs
@@ -8,7 +8,7 @@ use std::{fmt, ops};
 use {CompactSignature, Error, Message, Signature};
 
 /// Secret public key
-#[derive(Copy, Clone)]
+#[derive(Copy, Clone, Eq)]
 pub enum Public {
     /// Normal version of public key
     Normal(H520),
diff --git a/mm2src/mm2_bitcoin/script/src/sign.rs b/mm2src/mm2_bitcoin/script/src/sign.rs
index 58b3eea6fa..a560b22077 100644
--- a/mm2src/mm2_bitcoin/script/src/sign.rs
+++ b/mm2src/mm2_bitcoin/script/src/sign.rs
@@ -101,9 +101,9 @@ impl Sighash {
 #[derive(Clone, Debug)]
 pub struct UnsignedTransactionInput {
     pub previous_output: OutPoint,
+    pub prev_script: Script,
     pub sequence: u32,
     pub amount: u64,
-    pub witness: Vec<Vec<u8>>,
 }
 
 /// Used for resigning and loading test transactions
@@ -111,9 +111,9 @@ impl From<TransactionInput> for UnsignedTransactionInput {
     fn from(i: TransactionInput) -> Self {
         UnsignedTransactionInput {
             previous_output: i.previous_output,
+            prev_script: Vec::new().into(),
             sequence: i.sequence,
             amount: 0,
-            witness: i.script_witness.into_iter().map(Vec::from).collect(),
         }
     }
 }
@@ -662,8 +662,8 @@ mod tests {
                 index: previous_output_index,
                 hash: previous_tx_hash,
             },
+            prev_script: Vec::new().into(),
             amount: 0,
-            witness: vec![Vec::new()],
         };
 
         let output = TransactionOutput {
@@ -714,8 +714,8 @@ mod tests {
                 index: previous_output_index,
                 hash: previous_tx_hash,
             },
+            prev_script: Vec::new().into(),
             amount: 100,
-            witness: vec![Vec::new()],
         };
 
         let output = TransactionOutput {
diff --git a/mm2src/mm2_main/src/lp_native_dex.rs b/mm2src/mm2_main/src/lp_native_dex.rs
index f9aa565aed..dd6ea79caa 100644
--- a/mm2src/mm2_main/src/lp_native_dex.rs
+++ b/mm2src/mm2_main/src/lp_native_dex.rs
@@ -1,5 +1,5 @@
 /******************************************************************************
- * Copyright © 2023 Pampex LTD and TillyHK LTD              *
+ * Copyright © 2023 Pampex LTD and TillyHK LTD                                *
  *                                                                            *
  * See the CONTRIBUTOR-LICENSE-AGREEMENT, COPYING, LICENSE-COPYRIGHT-NOTICE   *
  * and DEVELOPER-CERTIFICATE-OF-ORIGIN files in the LEGAL directory in        *
diff --git a/mm2src/mm2_main/src/lp_network.rs b/mm2src/mm2_main/src/lp_network.rs
index 5f3227fed5..cd2b32c538 100644
--- a/mm2src/mm2_main/src/lp_network.rs
+++ b/mm2src/mm2_main/src/lp_network.rs
@@ -1,7 +1,7 @@
 // TODO: a lof of these implementations should be handled in `mm2_net`
 
 /******************************************************************************
- * Copyright © 2023 Pampex LTD and TillyHK LTD              *
+ * Copyright © 2023 Pampex LTD and TillyHK LTD                                *
  *                                                                            *
  * See the CONTRIBUTOR-LICENSE-AGREEMENT, COPYING, LICENSE-COPYRIGHT-NOTICE   *
  * and DEVELOPER-CERTIFICATE-OF-ORIGIN files in the LEGAL directory in        *
diff --git a/mm2src/mm2_main/src/lp_ordermatch.rs b/mm2src/mm2_main/src/lp_ordermatch.rs
index c2b2d44d0f..86e2fb0491 100644
--- a/mm2src/mm2_main/src/lp_ordermatch.rs
+++ b/mm2src/mm2_main/src/lp_ordermatch.rs
@@ -1,5 +1,5 @@
 /******************************************************************************
- * Copyright © 2023 Pampex LTD and TillyHK LTD              *
+ * Copyright © 2023 Pampex LTD and TillyHK LTD                                *
  *                                                                            *
  * See the CONTRIBUTOR-LICENSE-AGREEMENT, COPYING, LICENSE-COPYRIGHT-NOTICE   *
  * and DEVELOPER-CERTIFICATE-OF-ORIGIN files in the LEGAL directory in        *
diff --git a/mm2src/mm2_main/src/lp_swap.rs b/mm2src/mm2_main/src/lp_swap.rs
index 2263b0051d..51520c0860 100644
--- a/mm2src/mm2_main/src/lp_swap.rs
+++ b/mm2src/mm2_main/src/lp_swap.rs
@@ -37,7 +37,7 @@
 //!
 
 /******************************************************************************
- * Copyright © 2023 Pampex LTD and TillyHK LTD              *
+ * Copyright © 2023 Pampex LTD and TillyHK LTD                                *
  *                                                                            *
  * See the CONTRIBUTOR-LICENSE-AGREEMENT, COPYING, LICENSE-COPYRIGHT-NOTICE   *
  * and DEVELOPER-CERTIFICATE-OF-ORIGIN files in the LEGAL directory in        *
diff --git a/mm2src/mm2_main/src/mm2.rs b/mm2src/mm2_main/src/mm2.rs
index ea87efcab2..5bd85358cb 100644
--- a/mm2src/mm2_main/src/mm2.rs
+++ b/mm2src/mm2_main/src/mm2.rs
@@ -1,5 +1,5 @@
 /******************************************************************************
- * Copyright © 2023 Pampex LTD and TillyHK LTD              *
+ * Copyright © 2023 Pampex LTD and TillyHK LTD                                *
  *                                                                            *
  * See the CONTRIBUTOR-LICENSE-AGREEMENT, COPYING, LICENSE-COPYRIGHT-NOTICE   *
  * and DEVELOPER-CERTIFICATE-OF-ORIGIN files in the LEGAL directory in        *
diff --git a/mm2src/mm2_main/src/rpc.rs b/mm2src/mm2_main/src/rpc.rs
index fc1912e7f1..92422738f9 100644
--- a/mm2src/mm2_main/src/rpc.rs
+++ b/mm2src/mm2_main/src/rpc.rs
@@ -1,5 +1,5 @@
 /******************************************************************************
- * Copyright © 2023 Pampex LTD and TillyHK LTD              *
+ * Copyright © 2023 Pampex LTD and TillyHK LTD                                *
  *                                                                            *
  * See the CONTRIBUTOR-LICENSE-AGREEMENT, COPYING, LICENSE-COPYRIGHT-NOTICE   *
  * and DEVELOPER-CERTIFICATE-OF-ORIGIN files in the LEGAL directory in        *
diff --git a/mm2src/mm2_main/src/rpc/lp_commands/lp_commands_legacy.rs b/mm2src/mm2_main/src/rpc/lp_commands/lp_commands_legacy.rs
index f306ef859e..7e61b8c642 100644
--- a/mm2src/mm2_main/src/rpc/lp_commands/lp_commands_legacy.rs
+++ b/mm2src/mm2_main/src/rpc/lp_commands/lp_commands_legacy.rs
@@ -1,5 +1,5 @@
 /******************************************************************************
- * Copyright © 2023 Pampex LTD and TillyHK LTD              *
+ * Copyright © 2023 Pampex LTD and TillyHK LTD                                *
  *                                                                            *
  * See the CONTRIBUTOR-LICENSE-AGREEMENT, COPYING, LICENSE-COPYRIGHT-NOTICE   *
  * and DEVELOPER-CERTIFICATE-OF-ORIGIN files in the LEGAL directory in        *
diff --git a/mm2src/mm2_main/tests/docker_tests/docker_tests_common.rs b/mm2src/mm2_main/tests/docker_tests/docker_tests_common.rs
index dc1e55f99f..02088723b0 100644
--- a/mm2src/mm2_main/tests/docker_tests/docker_tests_common.rs
+++ b/mm2src/mm2_main/tests/docker_tests/docker_tests_common.rs
@@ -213,15 +213,13 @@ impl BchDockerOps {
 
         for _ in 0..18 {
             let key_pair = KeyPair::random_compressed();
-            let address_hash = key_pair.public().address_hash();
             let address = AddressBuilder::new(
                 Default::default(),
-                address_hash.into(),
                 Default::default(),
                 self.coin.as_ref().conf.address_prefixes.clone(),
                 None,
             )
-            .as_pkh()
+            .as_pkh_from_pk(*key_pair.public())
             .build()
             .expect("valid address props");
 
@@ -230,7 +228,7 @@ impl BchDockerOps {
                 .wait()
                 .unwrap();
 
-            let script_pubkey = Builder::build_p2pkh(&address_hash.into());
+            let script_pubkey = Builder::build_p2pkh(&key_pair.public().address_hash().into());
 
             bch_outputs.push(TransactionOutput {
                 value: 1000_00000000,
@@ -1025,7 +1023,6 @@ pub fn get_balance(mm: &MarketMakerIt, coin: &str) -> BalanceResponse {
 pub fn utxo_burn_address() -> Address {
     AddressBuilder::new(
         UtxoAddressFormat::Standard,
-        AddressHashEnum::default_address_hash(),
         ChecksumType::DSHA256,
         NetworkAddressPrefixes {
             p2pkh: [60].into(),
@@ -1033,7 +1030,7 @@ pub fn utxo_burn_address() -> Address {
         },
         None,
     )
-    .as_pkh()
+    .as_pkh(AddressHashEnum::default_address_hash())
     .build()
     .expect("valid address props")
 }
diff --git a/mm2src/mm2_main/tests/docker_tests/docker_tests_inner.rs b/mm2src/mm2_main/tests/docker_tests/docker_tests_inner.rs
index c198371f61..7b73ebafc3 100644
--- a/mm2src/mm2_main/tests/docker_tests/docker_tests_inner.rs
+++ b/mm2src/mm2_main/tests/docker_tests/docker_tests_inner.rs
@@ -355,6 +355,9 @@ fn test_one_hundred_maker_payments_in_a_row_native() {
                 },
                 value: tx.outputs[2].value,
                 height: None,
+                script: coin
+                    .script_for_address(&block_on(coin.as_ref().derivation_method.unwrap_single_addr()))
+                    .unwrap(),
             });
             sent_tx.push(tx);
         }
@@ -375,6 +378,7 @@ fn test_one_hundred_maker_payments_in_a_row_native() {
         },
         value: last_tx.outputs[2].value,
         height: None,
+        script: last_tx.outputs[2].script_pubkey.clone().into(),
     };
     assert_eq!(vec![expected_unspent], unspents);
 }
diff --git a/mm2src/mm2_main/tests/mm2_tests/mm2_tests_inner.rs b/mm2src/mm2_main/tests/mm2_tests/mm2_tests_inner.rs
index 78833da08f..02552cbab1 100644
--- a/mm2src/mm2_main/tests/mm2_tests/mm2_tests_inner.rs
+++ b/mm2src/mm2_main/tests/mm2_tests/mm2_tests_inner.rs
@@ -15,13 +15,14 @@ use mm2_test_helpers::for_tests::wait_check_stats_swap_status;
 use mm2_test_helpers::for_tests::{account_balance, btc_segwit_conf, btc_with_spv_conf, btc_with_sync_starting_header,
                                   check_recent_swaps, enable_qrc20, enable_utxo_v2_electrum, eth_dev_conf,
                                   find_metrics_in_json, from_env_file, get_new_address, get_shared_db_id, mm_spat,
-                                  morty_conf, rick_conf, sign_message, start_swaps, tbtc_segwit_conf,
-                                  tbtc_with_spv_conf, test_qrc20_history_impl, tqrc20_conf, verify_message,
-                                  wait_for_swaps_finish_and_check_status, wait_till_history_has_records,
-                                  MarketMakerIt, Mm2InitPrivKeyPolicy, Mm2TestConf, Mm2TestConfForSwap, RaiiDump,
-                                  DOC_ELECTRUM_ADDRS, ETH_MAINNET_NODE, ETH_MAINNET_SWAP_CONTRACT, ETH_SEPOLIA_NODES,
-                                  ETH_SEPOLIA_SWAP_CONTRACT, MARTY_ELECTRUM_ADDRS, MORTY, QRC20_ELECTRUMS, RICK,
-                                  RICK_ELECTRUM_ADDRS, TBTC_ELECTRUMS, T_BCH_ELECTRUMS};
+                                  morty_conf, my_balance, rick_conf, sign_message, start_swaps, tbtc_conf,
+                                  tbtc_segwit_conf, tbtc_with_spv_conf, test_qrc20_history_impl, tqrc20_conf,
+                                  verify_message, wait_for_swaps_finish_and_check_status,
+                                  wait_till_history_has_records, MarketMakerIt, Mm2InitPrivKeyPolicy, Mm2TestConf,
+                                  Mm2TestConfForSwap, RaiiDump, DOC_ELECTRUM_ADDRS, ETH_MAINNET_NODE,
+                                  ETH_MAINNET_SWAP_CONTRACT, ETH_SEPOLIA_NODES, ETH_SEPOLIA_SWAP_CONTRACT,
+                                  MARTY_ELECTRUM_ADDRS, MORTY, QRC20_ELECTRUMS, RICK, RICK_ELECTRUM_ADDRS,
+                                  TBTC_ELECTRUMS, T_BCH_ELECTRUMS};
 use mm2_test_helpers::get_passphrase;
 use mm2_test_helpers::structs::*;
 use serde_json::{self as json, json, Value as Json};
@@ -253,84 +254,45 @@ fn test_my_balance() {
     assert_eq!(my_address, "RRnMcSeKiLrNdbp91qNVQwwXx5azD4S4CD");
 }
 
+// TODO: Add a p2pk spending test in the docker tests when electrum nodes are available (also try to invoke the utxo cache by spending in rapid succession).
+#[test]
+fn test_p2pk_my_balance() {
+    // PK of the P2PK balance: 03f8f8fa2062590ba9a0a7a86f937de22f540c015864aad35a2a9f6766de906265
+    let seed = "salmon angle cushion sauce accuse earth volume until zone youth emerge favorite";
+    let coins = json!([tbtc_conf()]);
+    let conf = Mm2TestConf::seednode(seed, &coins);
+    let mm = MarketMakerIt::start(conf.conf, conf.rpc_password, None).unwrap();
+
+    let (_dump_log, _dump_dashboard) = mm.mm_dump();
+    log!("log path: {}", mm.log_path.display());
+
+    block_on(enable_electrum(&mm, "tBTC", false, TBTC_ELECTRUMS));
+    let my_balance = block_on(my_balance(&mm, "tBTC"));
+
+    assert_eq!(my_balance.balance, "0.00076".parse().unwrap());
+    assert_eq!(my_balance.unspendable_balance, BigDecimal::from(0));
+    // Even though the address is a P2PK, it's formatted as P2PKH like most explorers do.
+    assert_eq!(my_balance.address, "mgrM9w49Q7vqtroLKGekLTqCVFye5u6G3v");
+}
+
 #[test]
 #[cfg(not(target_arch = "wasm32"))]
 fn test_p2wpkh_my_balance() {
     let seed = "valley embody about obey never adapt gesture trust screen tube glide bread";
+    let coins = json!([tbtc_segwit_conf()]);
 
-    let coins = json! ([
-        {
-            "coin": "tBTC",
-            "name": "tbitcoin",
-            "fname": "tBitcoin",
-            "rpcport": 18332,
-            "pubtype": 111,
-            "p2shtype": 196,
-            "wiftype": 239,
-            "segwit": true,
-            "bech32_hrp": "tb",
-            "txfee": 0,
-            "estimate_fee_mode": "ECONOMICAL",
-            "mm2": 1,
-            "required_confirmations": 0,
-            "protocol": {
-                "type": "UTXO"
-            },
-            "address_format": {
-                "format":"segwit"
-            }
-        }
-    ]);
+    let conf = Mm2TestConf::seednode(seed, &coins);
+    let mm = MarketMakerIt::start(conf.conf, conf.rpc_password, None).unwrap();
 
-    let mm = MarketMakerIt::start(
-        json! ({
-            "gui": "nogui",
-            "netid": 9998,
-            "myipaddr": env::var ("BOB_TRADE_IP") .ok(),
-            "rpcip": env::var ("BOB_TRADE_IP") .ok(),
-            "passphrase": seed.to_string(),
-            "coins": coins,
-            "i_am_seed": true,
-            "rpc_password": "pass",
-        }),
-        "pass".into(),
-        None,
-    )
-    .unwrap();
     let (_dump_log, _dump_dashboard) = mm.mm_dump();
     log!("log path: {}", mm.log_path.display());
 
-    let electrum = block_on(mm.rpc(&json!({
-        "userpass": mm.userpass,
-        "method": "electrum",
-        "coin": "tBTC",
-        "servers": [{"url":"electrum1.cipig.net:10068"},{"url":"electrum2.cipig.net:10068"},{"url":"electrum3.cipig.net:10068"}],
-        "mm2": 1,
-        "address_format": {
-            "format": "segwit",
-        },
-    }))).unwrap();
-    assert_eq!(
-        electrum.0,
-        StatusCode::OK,
-        "RPC «electrum» failed with {} {}",
-        electrum.0,
-        electrum.1
-    );
+    block_on(enable_electrum(&mm, "tBTC-Segwit", false, TBTC_ELECTRUMS));
+    let my_balance = block_on(my_balance(&mm, "tBTC-Segwit"));
 
-    let my_balance = block_on(mm.rpc(&json! ({
-        "userpass": mm.userpass,
-        "method": "my_balance",
-        "coin": "tBTC",
-    })))
-    .unwrap();
-    let json: Json = json::from_str(&my_balance.1).unwrap();
-    let my_balance = json["balance"].as_str().unwrap();
-    assert_eq!(my_balance, "0.002");
-    let my_unspendable_balance = json["unspendable_balance"].as_str().unwrap();
-    assert_eq!(my_unspendable_balance, "0");
-    let my_address = json["address"].as_str().unwrap();
-    assert_eq!(my_address, "tb1qssfmay8nnghx7ynlznejnjxn6m4pemz9v7fsxy");
+    assert_eq!(my_balance.balance, "0.002".parse().unwrap());
+    assert_eq!(my_balance.unspendable_balance, "0".parse().unwrap());
+    assert_eq!(my_balance.address, "tb1qssfmay8nnghx7ynlznejnjxn6m4pemz9v7fsxy");
 }
 
 #[cfg(not(target_arch = "wasm32"))]
@@ -1127,74 +1089,23 @@ fn test_withdraw_and_send_hd() {
 #[cfg(not(target_arch = "wasm32"))]
 fn test_tbtc_withdraw_to_cashaddresses_should_fail() {
     let seed = "spice describe gravity federal blast come thank unfair canal monkey style afraid";
+    let coins = json!([tbtc_segwit_conf(),]);
 
-    let coins = json! ([
-        {
-            "coin": "tBTC",
-            "name": "tbitcoin",
-            "fname": "tBitcoin",
-            "rpcport": 18332,
-            "pubtype": 111,
-            "p2shtype": 196,
-            "wiftype": 239,
-            "segwit": true,
-            "bech32_hrp": "tb",
-            "txfee": 1000,
-            "mm2": 1,
-            "required_confirmations": 0,
-            "protocol": {
-                "type": "UTXO"
-            }
-        }
-    ]);
-
-    let mm_alice = MarketMakerIt::start(
-        json! ({
-            "gui": "nogui",
-            "netid": 8100,
-            "myipaddr": env::var ("ALICE_TRADE_IP") .ok(),
-            "rpcip": env::var ("ALICE_TRADE_IP") .ok(),
-            "passphrase": seed.to_string(),
-            "coins": coins,
-            "rpc_password": "password",
-            "i_am_seed": true,
-        }),
-        "password".into(),
-        None,
-    )
-    .unwrap();
+    let conf = Mm2TestConf::seednode(seed, &coins);
+    let mm_alice = MarketMakerIt::start(conf.conf, conf.rpc_password, None).unwrap();
 
     let (_alice_dump_log, _alice_dump_dashboard) = mm_alice.mm_dump();
     log!("Alice log path: {}", mm_alice.log_path.display());
 
-    // wait until RPC API is active
-
     // Enable coins. Print the replies in case we need the address.
-    let electrum = block_on(mm_alice.rpc(&json!({
-        "userpass": mm_alice.userpass,
-        "method": "electrum",
-        "coin": "tBTC",
-        "servers": [{"url":"electrum1.cipig.net:10068"},{"url":"electrum2.cipig.net:10068"},{"url":"electrum3.cipig.net:10068"}],
-        "mm2": 1,
-    }))).unwrap();
-    assert_eq!(
-        electrum.0,
-        StatusCode::OK,
-        "RPC «electrum» failed with {} {}",
-        electrum.0,
-        electrum.1
-    );
+    let electrum = block_on(enable_electrum(&mm_alice, "tBTC-Segwit", false, TBTC_ELECTRUMS));
     log!("enable_coins (alice): {:?}", electrum);
 
-    let electrum_response: CoinInitResponse = json::from_str(&electrum.1).expect("Expected 'CoinInitResponse'");
-    let mut enable_res = HashMap::new();
-    enable_res.insert("tBTC", electrum_response);
-
     // Send from BTC Legacy Address to Cashaddress should fail
     let withdraw = block_on(mm_alice.rpc(&json!({
         "userpass": mm_alice.userpass,
         "method": "withdraw",
-        "coin": "tBTC",
+        "coin": "tBTC-Segwit",
         "to": "bchtest:qqgp9xh3435xamv7ghct8emer2s2erzj8gx3gnhwkq",
         "amount": 0.00001,
     })))
@@ -1222,21 +1133,8 @@ fn test_withdraw_legacy() {
         {"coin":"MORTY_SEGWIT","asset":"MORTY_SEGWIT","txversion":4,"overwintered":1,"segwit":true,"txfee":1000,"protocol":{"type":"UTXO"}}
     ]);
 
-    let mm_alice = MarketMakerIt::start(
-        json!({
-            "gui": "nogui",
-            "netid": 8100,
-            "myipaddr": env::var ("ALICE_TRADE_IP") .ok(),
-            "rpcip": env::var ("ALICE_TRADE_IP") .ok(),
-            "passphrase": alice_passphrase,
-            "coins": coins,
-            "rpc_password": "password",
-            "i_am_seed": true,
-        }),
-        "password".into(),
-        None,
-    )
-    .unwrap();
+    let conf = Mm2TestConf::seednode(&alice_passphrase, &coins);
+    let mm_alice = MarketMakerIt::start(conf.conf, conf.rpc_password, None).unwrap();
 
     let (_alice_dump_log, _alice_dump_dashboard) = mm_alice.mm_dump();
     log!("Alice log path: {}", mm_alice.log_path.display());
@@ -1280,75 +1178,23 @@ fn test_withdraw_legacy() {
 #[cfg(not(target_arch = "wasm32"))]
 fn test_withdraw_segwit() {
     let seed = "spice describe gravity federal blast come thank unfair canal monkey style afraid";
+    let coins = json!([tbtc_segwit_conf()]);
 
-    let coins = json!([
-        {
-            "coin": "tBTC",
-            "name": "tbitcoin",
-            "fname": "tBitcoin",
-            "rpcport": 18332,
-            "pubtype": 111,
-            "p2shtype": 196,
-            "wiftype": 239,
-            "segwit": true,
-            "bech32_hrp": "tb",
-            "txfee": 1000,
-            "mm2": 1,
-            "required_confirmations": 0,
-            "protocol": {
-                "type": "UTXO"
-            },
-            "address_format": {
-                "format":"segwit"
-            }
-        }
-    ]);
-
-    let mm_alice = MarketMakerIt::start(
-        json!({
-            "gui": "nogui",
-            "netid": 8100,
-            "myipaddr": env::var ("ALICE_TRADE_IP") .ok(),
-            "rpcip": env::var ("ALICE_TRADE_IP") .ok(),
-            "passphrase": seed.to_string(),
-            "coins": coins,
-            "rpc_password": "password",
-            "i_am_seed": true,
-        }),
-        "password".into(),
-        None,
-    )
-    .unwrap();
+    let conf = Mm2TestConf::seednode(seed, &coins);
+    let mm_alice = MarketMakerIt::start(conf.conf, conf.rpc_password, None).unwrap();
 
     let (_alice_dump_log, _alice_dump_dashboard) = mm_alice.mm_dump();
     log!("Alice log path: {}", mm_alice.log_path.display());
 
-    // wait until RPC API is active
-
     // Enable coins. Print the replies in case we need the address.
-    let electrum = block_on(mm_alice.rpc(&json!({
-        "userpass": mm_alice.userpass,
-        "method": "electrum",
-        "coin": "tBTC",
-        "servers": [{"url":"electrum1.cipig.net:10068"},{"url":"electrum2.cipig.net:10068"},{"url":"electrum3.cipig.net:10068"}],
-        "mm2": 1,
-        "address_format": {
-            "format": "segwit",
-        },
-    }))).unwrap();
-    assert_eq!(
-        electrum.0,
-        StatusCode::OK,
-        "RPC «electrum» failed with {} {}",
-        electrum.0,
-        electrum.1
-    );
+    let electrum = block_on(enable_electrum(&mm_alice, "tBTC-Segwit", false, TBTC_ELECTRUMS));
+
     log!("enable_coins (alice): {:?}", electrum);
 
     let withdraw = block_on(mm_alice.rpc(&json!({
         "userpass": mm_alice.userpass,
         "method": "withdraw",
-        "coin": "tBTC",
+        "coin": "tBTC-Segwit",
         "to": "tb1qdkwjk42dw6pryvs9sl0ht3pn3mxghuma64jst5",
         "amount": 0.00001,
     })))
@@ -1361,7 +1207,7 @@ fn test_withdraw_segwit() {
     let withdraw = block_on(mm_alice.rpc(&json!({
         "userpass": mm_alice.userpass,
         "method": "withdraw",
-        "coin": "tBTC",
+        "coin": "tBTC-Segwit",
         "to": "ltc1qdkwjk42dw6pryvs9sl0ht3pn3mxghuma64jst5",
         "amount": 0.00001,
     })))
@@ -1383,7 +1229,7 @@ fn test_withdraw_segwit() {
     let withdraw = block_on(mm_alice.rpc(&json!({
         "userpass": mm_alice.userpass,
         "method": "withdraw",
-        "coin": "tBTC",
+        "coin": "tBTC-Segwit",
         "to": "tb1p6h5fuzmnvpdthf5shf0qqjzwy7wsqc5rhmgq2ks9xrak4ry6mtrscsqvzp",
         "amount": 0.00001,
     })))
@@ -2708,55 +2554,22 @@ fn test_convert_utxo_address() {
 #[test]
 #[cfg(not(target_arch = "wasm32"))]
 fn test_convert_segwit_address() {
-    let coins = json! ([
-        {
-            "coin": "tBTC",
-            "name": "tbitcoin",
-            "fname": "tBitcoin",
-            "rpcport": 18332,
-            "pubtype": 111,
-            "p2shtype": 196,
-            "wiftype": 239,
-            "segwit": true,
-            "bech32_hrp": "tb",
-            "txfee": 1000,
-            "mm2": 1,
-            "required_confirmations": 0,
-            "protocol": {
-                "type": "UTXO"
-            }
-        }
-    ]);
+    let seed = "face pin block number add byte put seek mime test note password sin tab multiple";
+    let coins = json!([tbtc_segwit_conf(),]);
+
+    let conf = Mm2TestConf::seednode(seed, &coins);
+    let mm = MarketMakerIt::start(conf.conf, conf.rpc_password, None).unwrap();
 
-    let mm = MarketMakerIt::start(
-        json! ({
-            "gui": "nogui",
-            "netid": 9998,
-            "myipaddr": env::var ("BOB_TRADE_IP") .ok(),
-            "rpcip": env::var ("BOB_TRADE_IP") .ok(),
-            "passphrase": "face pin block number add byte put seek mime test note password sin tab multiple",
-            "coins": coins,
-            "i_am_seed": true,
-            "rpc_password": "pass",
-        }),
-        "pass".into(),
-        None,
-    )
-    .unwrap();
     let (_dump_log, _dump_dashboard) = mm.mm_dump();
     log!("log path: {}", mm.log_path.display());
 
-    let _electrum = block_on(enable_electrum(&mm, "tBTC", false, &[
-        "electrum1.cipig.net:10068",
-        "electrum2.cipig.net:10068",
-        "electrum3.cipig.net:10068",
-    ]));
+    let _electrum = block_on(enable_electrum(&mm, "tBTC-Segwit", false, TBTC_ELECTRUMS));
 
     // test standard to segwit
     let rc = block_on(mm.rpc(&json! ({
         "userpass": mm.userpass,
         "method": "convertaddress",
-        "coin": "tBTC",
+        "coin": "tBTC-Segwit",
         "from": "mqWYEGxLeK843n3xMTe8EWTFPyoSZjtUXb",
         "to_address_format":{"format":"segwit"},
     })))
@@ -2780,7 +2593,7 @@ fn test_convert_segwit_address() {
     let rc = block_on(mm.rpc(&json! ({
         "userpass": mm.userpass,
         "method": "convertaddress",
-        "coin": "tBTC",
+        "coin": "tBTC-Segwit",
         "from": "tb1qdkwjk42dw6pryvs9sl0ht3pn3mxghuma64jst5",
         "to_address_format":{"format":"standard"},
     })))
@@ -2804,7 +2617,7 @@ fn test_convert_segwit_address() {
     let rc = block_on(mm.rpc(&json! ({
         "userpass": mm.userpass,
         "method": "convertaddress",
-        "coin": "tBTC",
+        "coin": "tBTC-Segwit",
         "from": "1AzawDsMqHgoGfaLdtfkQbEvXzCjk5oyFx",
         "to_address_format":{"format":"segwit"},
     })))
@@ -2820,7 +2633,7 @@ fn test_convert_segwit_address() {
     let rc = block_on(mm.rpc(&json! ({
         "userpass": mm.userpass,
         "method": "convertaddress",
-        "coin": "tBTC",
+        "coin": "tBTC-Segwit",
         "from": "ltc1qdkwjk42dw6pryvs9sl0ht3pn3mxghuma64jst5",
         "to_address_format":{"format":"standard"},
     })))
@@ -3431,80 +3244,23 @@ fn test_validateaddress() {
 #[cfg(not(target_arch = "wasm32"))]
 fn test_validateaddress_segwit() {
     let seed = "spice describe gravity federal blast come thank unfair canal monkey style afraid";
+    let coins = json!([tbtc_segwit_conf(),]);
 
-    let coins = json! ([
-        {
-            "coin": "tBTC",
-            "name": "tbitcoin",
-            "fname": "tBitcoin",
-            "rpcport": 18332,
-            "pubtype": 111,
-            "p2shtype": 196,
-            "wiftype": 239,
-            "segwit": true,
-            "bech32_hrp": "tb",
-            "txfee": 1000,
-            "mm2": 1,
-            "required_confirmations": 0,
-            "protocol": {
-                "type": "UTXO"
-            },
-            "address_format": {
-                "format":"segwit"
-            }
-        }
-    ]);
-
-    let mm_alice = MarketMakerIt::start(
-        json! ({
-            "gui": "nogui",
-            "netid": 8100,
-            "myipaddr": env::var ("ALICE_TRADE_IP") .ok(),
-            "rpcip": env::var ("ALICE_TRADE_IP") .ok(),
-            "passphrase": seed.to_string(),
-            "coins": coins,
-            "rpc_password": "password",
-            "i_am_seed": true,
-        }),
-        "password".into(),
-        None,
-    )
-    .unwrap();
+    let conf = Mm2TestConf::seednode(seed, &coins);
+    let mm_alice = MarketMakerIt::start(conf.conf, conf.rpc_password, None).unwrap();
 
     let (_alice_dump_log, _alice_dump_dashboard) = mm_alice.mm_dump();
     log!("Alice log path: {}", mm_alice.log_path.display());
 
-    // wait until RPC API is active
-
     // Enable coins. Print the replies in case we need the address.
-    let electrum = block_on(mm_alice.rpc(&json!({
-        "userpass": mm_alice.userpass,
-        "method": "electrum",
-        "coin": "tBTC",
-        "servers": [{"url":"electrum1.cipig.net:10068"},{"url":"electrum2.cipig.net:10068"},{"url":"electrum3.cipig.net:10068"}],
-        "mm2": 1,
-        "address_format": {
-            "format": "segwit",
-        },
-    }))).unwrap();
-    assert_eq!(
-        electrum.0,
-        StatusCode::OK,
-        "RPC «electrum» failed with {} {}",
-        electrum.0,
-        electrum.1
-    );
+    let electrum = block_on(enable_electrum(&mm_alice, "tBTC-Segwit", false, TBTC_ELECTRUMS));
     log!("enable_coins (alice): {:?}", electrum);
 
-    let electrum_response: CoinInitResponse = json::from_str(&electrum.1).expect("Expected 'CoinInitResponse'");
-    let mut enable_res = HashMap::new();
-    enable_res.insert("tBTC", electrum_response);
-
     // test valid Segwit address
     let rc = block_on(mm_alice.rpc(&json! ({
         "userpass": mm_alice.userpass,
         "method": "validateaddress",
-        "coin": "tBTC",
+        "coin": "tBTC-Segwit",
         "address": "tb1qdkwjk42dw6pryvs9sl0ht3pn3mxghuma64jst5",
     })))
     .unwrap();
@@ -3527,7 +3283,7 @@ fn test_validateaddress_segwit() {
     let rc = block_on(mm_alice.rpc(&json! ({
         "userpass": mm_alice.userpass,
         "method": "validateaddress",
-        "coin": "tBTC",
+        "coin": "tBTC-Segwit",
         "address": "bc1qdkwjk42dw6pryvs9sl0ht3pn3mxghuma64jst5",
     })))
     .unwrap();
@@ -3966,62 +3722,25 @@ fn test_qrc20_tx_history() { block_on(test_qrc20_history_impl(None)); }
 #[cfg(not(target_arch = "wasm32"))]
 fn test_tx_history_segwit() {
     let passphrase = "also shoot benefit prefer juice shell elder veteran woman mimic image kidney";
-    let coins = json!([
-        {"coin":"tBTC","name":"tbitcoin","fname":"tBitcoin","rpcport":18332,"pubtype":111,"p2shtype":196,"wiftype":239,"segwit":true,"bech32_hrp":"tb","txfee":0,"estimate_fee_mode":"ECONOMICAL","mm2":1,"required_confirmations":0,"protocol":{"type":"UTXO"},"address_format":{"format":"segwit"}},
-    ]);
+    let coins = json!([tbtc_segwit_conf(),]);
+
+    let conf = Mm2TestConf::seednode(passphrase, &coins);
+    let mm = MarketMakerIt::start(conf.conf, conf.rpc_password, None).unwrap();
 
-    let mm = MarketMakerIt::start(
-        json! ({
-            "gui": "nogui",
-            "netid": 9998,
-            "myipaddr": env::var ("BOB_TRADE_IP") .ok(),
-            "rpcip": env::var ("BOB_TRADE_IP") .ok(),
-            "passphrase": passphrase,
-            "coins": coins,
-            "i_am_seed": true,
-            "rpc_password": "pass",
-            "metrics_interval": 30.,
-        }),
-        "pass".into(),
-        None,
-    )
-    .unwrap();
     let (_dump_log, _dump_dashboard) = mm.mm_dump();
     log!("log path: {}", mm.log_path.display());
 
     // enable tBTC to see that to/from segwit addresses are displayed correctly in tx_history
     // and that tx_history is retrieved for the segwit address instead of legacy
-    let electrum = block_on(mm.rpc(&json!({
-        "userpass": mm.userpass,
-        "method": "electrum",
-        "coin": "tBTC",
-        "servers": [{"url":"electrum1.cipig.net:10068"},{"url":"electrum2.cipig.net:10068"},{"url":"electrum3.cipig.net:10068"}],
-        "mm2": 1,
-        "tx_history": true,
-        "address_format": {
-            "format": "segwit",
-        },
-    })))
-        .unwrap();
-    assert_eq!(
-        electrum.0,
-        StatusCode::OK,
-        "RPC «electrum» failed with status «{}», response «{}»",
-        electrum.0,
-        electrum.1
-    );
-    let electrum_json: Json = json::from_str(&electrum.1).unwrap();
-    assert_eq!(
-        electrum_json["address"].as_str(),
-        Some("tb1qdkwjk42dw6pryvs9sl0ht3pn3mxghuma64jst5")
-    );
+    let electrum = block_on(enable_electrum(&mm, "tBTC-Segwit", false, TBTC_ELECTRUMS));
+    assert_eq!(&electrum.address, "tb1qdkwjk42dw6pryvs9sl0ht3pn3mxghuma64jst5");
 
     block_on(wait_till_history_has_records(&mm, "tBTC", 13));
 
     let tx_history = block_on(mm.rpc(&json!({
         "userpass": mm.userpass,
         "method": "my_tx_history",
-        "coin": "tBTC",
+        "coin": "tBTC-Segwit",
         "limit": 13,
     })))
     .unwrap();
@@ -4092,51 +3811,17 @@ fn test_tx_history_segwit() {
 #[cfg(not(target_arch = "wasm32"))]
 fn test_tx_history_tbtc_non_segwit() {
     let passphrase = "also shoot benefit prefer juice shell elder veteran woman mimic image kidney";
-    let coins = json!([
-        {"coin":"tBTC","name":"tbitcoin","fname":"tBitcoin","rpcport":18332,"pubtype":111,"p2shtype":196,"wiftype":239,"segwit":true,"bech32_hrp":"tb","txfee":0,"estimate_fee_mode":"ECONOMICAL","mm2":1,"required_confirmations":0,"protocol":{"type":"UTXO"}},
-    ]);
+    let coins = json!([tbtc_segwit_conf(),]);
+
+    let conf = Mm2TestConf::seednode(passphrase, &coins);
+    let mm = MarketMakerIt::start(conf.conf, conf.rpc_password, None).unwrap();
 
-    let mm = MarketMakerIt::start(
-        json! ({
-            "gui": "nogui",
-            "netid": 9998,
-            "myipaddr": env::var ("BOB_TRADE_IP") .ok(),
-            "rpcip": env::var ("BOB_TRADE_IP") .ok(),
-            "passphrase": passphrase,
-            "coins": coins,
-            "i_am_seed": true,
-            "rpc_password": "pass",
-            "metrics_interval": 30.,
-        }),
-        "pass".into(),
-        None,
-    )
-    .unwrap();
     let (_dump_log, _dump_dashboard) = mm.mm_dump();
     log!("log path: {}", mm.log_path.display());
 
     // enable tBTC in legacy first to see that to/from segwit addresses are displayed correctly in tx_history
-    let electrum = block_on(mm.rpc(&json!({
-        "userpass": mm.userpass,
-        "method": "electrum",
-        "coin": "tBTC",
-        "servers": [{"url":"electrum1.cipig.net:10068"},{"url":"electrum2.cipig.net:10068"},{"url":"electrum3.cipig.net:10068"}],
-        "mm2": 1,
-        "tx_history": true,
-    })))
-        .unwrap();
-    assert_eq!(
-        electrum.0,
-        StatusCode::OK,
-        "RPC «electrum» failed with status «{}», response «{}»",
-        electrum.0,
-        electrum.1
-    );
-    let electrum_json: Json = json::from_str(&electrum.1).unwrap();
-    assert_eq!(
-        electrum_json["address"].as_str(),
-        Some("mqWYEGxLeK843n3xMTe8EWTFPyoSZjtUXb")
-    );
+    let electrum = block_on(enable_electrum(&mm, "tBTC-Segwit", false, TBTC_ELECTRUMS));
+    assert_eq!(&electrum.address, "mqWYEGxLeK843n3xMTe8EWTFPyoSZjtUXb");
 
     let expected = vec![
         // https://live.blockcypher.com/btc-testnet/tx/a41b2e5f0741d1dcbc309ce4c43fde1ad44c5e61bb34778ab0bf9f3d9fd6fb6c/
@@ -4187,12 +3872,12 @@ fn test_tx_history_tbtc_non_segwit() {
         "649d514d76702a0925a917d830e407f4f1b52d78832520e486c140ce8d0b879f",
     ];
 
-    block_on(wait_till_history_has_records(&mm, "tBTC", expected.len()));
+    block_on(wait_till_history_has_records(&mm, "tBTC-Segwit", expected.len()));
 
     let tx_history = block_on(mm.rpc(&json!({
         "userpass": mm.userpass,
         "method": "my_tx_history",
-        "coin": "tBTC",
+        "coin": "tBTC-Segwit",
         "limit": 100,
     })))
     .unwrap();
@@ -6177,6 +5862,9 @@ fn test_sign_raw_transaction_p2wpkh() {
 
     // start bob
     let mm_bob = MarketMakerIt::start(conf.conf, conf.rpc_password, None).unwrap();
+
+    let (_bob_dump_log, _bob_dump_dashboard) = mm_bob.mm_dump();
+    log!("Bob log path: {}", mm_bob.log_path.display());
     // Enable coins on Bob side. Print the replies in case we need the "address".
     let coin_init_resp = block_on(enable_electrum(&mm_bob, "tBTC-Segwit", false, TBTC_ELECTRUMS));
     assert_eq!(
@@ -6207,7 +5895,7 @@ fn test_sign_raw_transaction_p2wpkh() {
     // bad request: spend from two different addresses
     let response = block_on(test_sign_raw_transaction_rpc_helper(
         &mm_bob,
-        StatusCode::BAD_REQUEST,
+        StatusCode::INTERNAL_SERVER_ERROR,
         &json!({
             "coin": "tBTC-Segwit",
             "type": "UTXO",
@@ -6221,16 +5909,14 @@ fn test_sign_raw_transaction_p2wpkh() {
                 }, {
                     "tx_hash": "96c92f063da58f1f2defd14bf8f3780130c094ce3072133d83c6426ae7767c25",
                     "index": 0,
+                    // We don't own this address. Thus we will fail while signing this input.
                     "script_pub_key": "00146538caea0d5579f5b9f4e19ddbe2d6c663f3ea56",
                     "amount": 0.00002306,
                 }]
             }
         }),
     ));
-    assert_eq!(
-        response["error"],
-        Json::from("Invalid param: spends are from same address only")
-    );
+    assert!(response["error"].as_str().unwrap().contains("Signing error"));
 }
 
 #[cfg(all(feature = "run-device-tests", not(target_arch = "wasm32")))]