From e1505375387907c980c37ee5fc860a43013bb6ff Mon Sep 17 00:00:00 2001
From: GeneFerneau <gene@ferneau.link>
Date: Fri, 30 Jul 2021 06:03:58 +0000
Subject: [PATCH] WalletSwapCoin: Split into two classes + add trait

Convert WalletSwapCoin into Incoming/OutgoingSwapCoin, and add a
WalletSwapCoin trait for common functionality
---
 src/contracts.rs      | 127 ++++++++++++---
 src/main.rs           |  54 +++----
 src/maker_protocol.rs |  48 ++++--
 src/messages.rs       |   4 +-
 src/taker_protocol.rs |  27 ++--
 src/wallet_sync.rs    | 364 +++++++++++++++++++++++++++++++++---------
 6 files changed, 464 insertions(+), 160 deletions(-)

diff --git a/src/contracts.rs b/src/contracts.rs
index dc3eb077..ddc1348e 100644
--- a/src/contracts.rs
+++ b/src/contracts.rs
@@ -23,7 +23,9 @@ use rand::RngCore;
 
 use crate::error::Error;
 use crate::messages::ConfirmedCoinSwapTxInfo;
-use crate::wallet_sync::{create_multisig_redeemscript, Wallet, WalletSwapCoin, NETWORK};
+use crate::wallet_sync::{
+    create_multisig_redeemscript, IncomingSwapCoin, OutgoingSwapCoin, Wallet, NETWORK,
+};
 
 //TODO should be configurable somehow
 //relatively low value for now so that its easier to test on regtest
@@ -49,6 +51,8 @@ pub trait SwapCoin {
     fn verify_contract_tx_receiver_sig(&self, sig: &Signature) -> bool;
     fn verify_contract_tx_sender_sig(&self, sig: &Signature) -> bool;
     fn apply_privkey(&mut self, privkey: SecretKey) -> Result<(), Error>;
+    fn contract_type(&self) -> &str;
+    fn is_known(&self) -> bool;
 }
 
 pub fn calculate_maker_pubkey_from_nonce(
@@ -457,7 +461,7 @@ fn verify_contract_tx_sig(
     secp.verify(&sighash, sig, &pubkey.key).is_ok()
 }
 
-impl SwapCoin for WalletSwapCoin {
+impl SwapCoin for IncomingSwapCoin {
     fn get_multisig_redeemscript(&self) -> Script {
         let secp = Secp256k1::new();
         create_multisig_redeemscript(
@@ -501,35 +505,104 @@ impl SwapCoin for WalletSwapCoin {
         self.other_privkey = Some(privkey);
         Ok(())
     }
-}
 
-impl WalletSwapCoin {
-    //"_with_my_privkey" as opposed to with other_privkey
-    pub fn sign_contract_tx_with_my_privkey(
-        &self,
-        contract_tx: &Transaction,
-    ) -> Result<Signature, Error> {
-        let multisig_redeemscript = self.get_multisig_redeemscript();
-        Ok(sign_contract_tx(
-            contract_tx,
-            &multisig_redeemscript,
-            self.funding_amount,
-            &self.my_privkey,
-        )
-        .map_err(|_| Error::Protocol("error with signing contract tx"))?)
+    fn contract_type(&self) -> &str {
+        self.type_string()
     }
 
-    pub fn verify_contract_tx_sig(&self, sig: &Signature) -> bool {
-        verify_contract_tx_sig(
-            &self.contract_tx,
-            &self.get_multisig_redeemscript(),
-            self.funding_amount,
+    fn is_known(&self) -> bool {
+        self.contract_privkey_is_known()
+    }
+}
+
+impl SwapCoin for OutgoingSwapCoin {
+    fn get_multisig_redeemscript(&self) -> Script {
+        let secp = Secp256k1::new();
+        create_multisig_redeemscript(
             &self.other_pubkey,
-            sig,
+            &PublicKey {
+                compressed: true,
+                key: secp256k1::PublicKey::from_secret_key(&secp, &self.my_privkey),
+            },
         )
     }
+
+    fn get_contract_tx(&self) -> Transaction {
+        self.contract_tx.clone()
+    }
+
+    fn get_contract_redeemscript(&self) -> Script {
+        self.contract_redeemscript.clone()
+    }
+
+    fn get_funding_amount(&self) -> u64 {
+        self.funding_amount
+    }
+
+    fn verify_contract_tx_receiver_sig(&self, sig: &Signature) -> bool {
+        self.verify_contract_tx_sig(sig)
+    }
+
+    fn verify_contract_tx_sender_sig(&self, sig: &Signature) -> bool {
+        self.verify_contract_tx_sig(sig)
+    }
+
+    fn apply_privkey(&mut self, privkey: SecretKey) -> Result<(), Error> {
+        let secp = Secp256k1::new();
+        let pubkey = PublicKey {
+            compressed: true,
+            key: secp256k1::PublicKey::from_secret_key(&secp, &privkey),
+        };
+        if pubkey == self.other_pubkey {
+            Ok(())
+        } else {
+            Err(Error::Protocol("not correct privkey"))
+        }
+    }
+
+    fn contract_type(&self) -> &str {
+        self.type_string()
+    }
+
+    fn is_known(&self) -> bool {
+        self.contract_privkey_is_known()
+    }
 }
 
+macro_rules! sign_and_verify_contract {
+    ($coin:ident) => {
+        impl $coin {
+            //"_with_my_privkey" as opposed to with other_privkey
+            pub fn sign_contract_tx_with_my_privkey(
+                &self,
+                contract_tx: &Transaction,
+            ) -> Result<Signature, Error> {
+                let multisig_redeemscript = self.get_multisig_redeemscript();
+                Ok(sign_contract_tx(
+                    contract_tx,
+                    &multisig_redeemscript,
+                    self.funding_amount,
+                    &self.my_privkey,
+                )
+                .map_err(|_| Error::Protocol("error with signing contract tx"))?)
+            }
+
+            pub fn verify_contract_tx_sig(&self, sig: &Signature) -> bool {
+                verify_contract_tx_sig(
+                    &self.contract_tx,
+                    &self.get_multisig_redeemscript(),
+                    self.funding_amount,
+                    &self.other_pubkey,
+                    sig,
+                )
+            }
+        }
+    };
+}
+
+sign_and_verify_contract!(IncomingSwapCoin);
+sign_and_verify_contract!(OutgoingSwapCoin);
+
 impl SwapCoin for WatchOnlySwapCoin {
     fn get_multisig_redeemscript(&self) -> Script {
         create_multisig_redeemscript(&self.sender_pubkey, &self.receiver_pubkey)
@@ -582,6 +655,14 @@ impl SwapCoin for WatchOnlySwapCoin {
             Err(Error::Protocol("not correct privkey"))
         }
     }
+
+    fn contract_type(&self) -> &str {
+        "watchonly"
+    }
+
+    fn is_known(&self) -> bool {
+        false
+    }
 }
 
 impl WatchOnlySwapCoin {
diff --git a/src/main.rs b/src/main.rs
index 9833056e..e01af8f1 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -8,8 +8,6 @@ use std::path::PathBuf;
 use std::sync::{Arc, RwLock};
 
 use bitcoin::hashes::hex::ToHex;
-use bitcoin::secp256k1::Secp256k1;
-use bitcoin::util::key::PublicKey;
 use bitcoin::Amount;
 use bitcoin_wallet::mnemonic;
 use bitcoincore_rpc::{Auth, Client, Error, RpcApi};
@@ -20,10 +18,7 @@ mod wallet_sync;
 use wallet_sync::Wallet;
 
 mod contracts;
-use contracts::{
-    read_hashlock_pubkey_from_contract, read_locktime_from_contract,
-    read_timelock_pubkey_from_contract,
-};
+use contracts::{read_locktime_from_contract, SwapCoin};
 
 mod error;
 mod maker_protocol;
@@ -173,39 +168,34 @@ fn display_wallet_balance(wallet_file_name: &PathBuf, long_form: Option<bool>) {
     println!("coin count = {}", utxo_count);
     println!("total balance = {}", balance);
 
-    let secp = Secp256k1::new();
     let incomplete_coinswaps = wallet.find_incomplete_coinswaps(&rpc).unwrap();
     if incomplete_coinswaps.len() > 0 {
         println!("= incomplete coinswaps =");
-        for (hashvalue, utxo_swapcoins) in incomplete_coinswaps {
-            let balance: Amount = utxo_swapcoins
+        for (hashvalue, (utxo_incoming_swapcoins, utxo_outgoing_swapcoins)) in incomplete_coinswaps
+        {
+            let balance: Amount = utxo_incoming_swapcoins
                 .iter()
+                .map(|(l, i)| (l, (*i as &dyn SwapCoin)))
+                .chain(
+                    utxo_outgoing_swapcoins
+                        .iter()
+                        .map(|(l, o)| (l, (*o as &dyn SwapCoin))),
+                )
                 .fold(Amount::ZERO, |acc, us| acc + us.0.amount);
             println!(
                 "{:16} {:8} {:8} {:<15} {:<7} value",
                 "outpoint", "type", "preimage", "locktime/blocks", "conf",
             );
-            for (utxo, swapcoin) in utxo_swapcoins {
+            for (utxo, swapcoin) in utxo_incoming_swapcoins
+                .iter()
+                .map(|(l, i)| (l, (*i as &dyn SwapCoin)))
+                .chain(
+                    utxo_outgoing_swapcoins
+                        .iter()
+                        .map(|(l, o)| (l, (*o as &dyn SwapCoin))),
+                )
+            {
                 let txid = utxo.txid.to_hex();
-                let contract_pubkey = PublicKey {
-                    compressed: true,
-                    key: bitcoin::secp256k1::PublicKey::from_secret_key(
-                        &secp,
-                        &swapcoin.contract_privkey,
-                    ),
-                };
-                let type_string = if contract_pubkey
-                    == read_hashlock_pubkey_from_contract(&swapcoin.contract_redeemscript).unwrap()
-                {
-                    "hashlock"
-                } else {
-                    assert_eq!(
-                        contract_pubkey,
-                        read_timelock_pubkey_from_contract(&swapcoin.contract_redeemscript)
-                            .unwrap()
-                    );
-                    "timelock"
-                };
 
                 #[rustfmt::skip]
                 println!("{}{}{}:{} {:8} {:8} {:^15} {:<7} {}",
@@ -213,9 +203,9 @@ fn display_wallet_balance(wallet_file_name: &PathBuf, long_form: Option<bool>) {
                     if long_form { "" } else { ".." },
                     if long_form { &"" } else { &txid[58..64] },
                     utxo.vout,
-                    type_string,
-                    if swapcoin.hash_preimage.is_some() { "known" } else { "unknown" },
-                    read_locktime_from_contract(&swapcoin.contract_redeemscript)
+                    swapcoin.contract_type(),
+                    if swapcoin.is_known() { "known" } else { "unknown" },
+                    read_locktime_from_contract(&swapcoin.get_contract_redeemscript())
                         .expect("unable to read locktime from contract"),
                     utxo.confirmations,
                     utxo.amount
diff --git a/src/maker_protocol.rs b/src/maker_protocol.rs
index 37a99f1b..3e304aa8 100644
--- a/src/maker_protocol.rs
+++ b/src/maker_protocol.rs
@@ -27,7 +27,7 @@ use crate::messages::{
     SendersContractSig, SignReceiversContractTx, SignSendersAndReceiversContractTxes,
     SignSendersContractTx, SwapCoinPrivateKey, TakerToMakerMessage,
 };
-use crate::wallet_sync::{CoreAddressLabelType, Wallet, WalletSwapCoin};
+use crate::wallet_sync::{CoreAddressLabelType, IncomingSwapCoin, OutgoingSwapCoin, Wallet};
 
 // A structure denoting expectation of type of taker message.
 // Used in the [ConnectionState] structure.
@@ -56,8 +56,8 @@ pub async fn start_maker(rpc: Arc<Client>, wallet: Arc<RwLock<Wallet>>, port: u1
 
 struct ConnectionState {
     allowed_message: ExpectedMessage,
-    incoming_swapcoins: Option<Vec<WalletSwapCoin>>,
-    outgoing_swapcoins: Option<Vec<WalletSwapCoin>>,
+    incoming_swapcoins: Option<Vec<IncomingSwapCoin>>,
+    outgoing_swapcoins: Option<Vec<OutgoingSwapCoin>>,
     pending_funding_txes: Option<Vec<Transaction>>,
 }
 
@@ -399,7 +399,7 @@ fn handle_proof_of_funding(
 
     log::trace!(target: "maker", "proof of funding valid, creating own funding txes");
 
-    connection_state.incoming_swapcoins = Some(Vec::<WalletSwapCoin>::new());
+    connection_state.incoming_swapcoins = Some(Vec::<IncomingSwapCoin>::new());
     for (funding_info, &funding_output_index, &funding_output, &incoming_swapcoin_keys) in izip!(
         proof.confirmed_funding_txes.iter(),
         funding_output_indexes.iter(),
@@ -434,7 +434,7 @@ fn handle_proof_of_funding(
             .incoming_swapcoins
             .as_mut()
             .unwrap()
-            .push(WalletSwapCoin::new(
+            .push(IncomingSwapCoin::new(
                 coin_privkey,
                 coin_other_pubkey,
                 my_receivers_contract_tx.clone(),
@@ -553,10 +553,10 @@ fn handle_senders_and_receivers_contract_sigs(
     let mut w = wallet.write().unwrap();
     incoming_swapcoins
         .iter()
-        .for_each(|incoming_swapcoin| w.add_swapcoin(incoming_swapcoin.clone()));
+        .for_each(|incoming_swapcoin| w.add_incoming_swapcoin(incoming_swapcoin.clone()));
     outgoing_swapcoins
         .iter()
-        .for_each(|outgoing_swapcoin| w.add_swapcoin(outgoing_swapcoin.clone()));
+        .for_each(|outgoing_swapcoin| w.add_outgoing_swapcoin(outgoing_swapcoin.clone()));
     w.update_swap_coins_list()?;
 
     //TODO add coin to watchtowers
@@ -586,12 +586,20 @@ fn handle_sign_receivers_contract_tx(
     let mut sigs = Vec::<Signature>::new();
     for receivers_contract_tx_info in message.txes {
         sigs.push(
-            wallet
+            if let Some(c) = wallet
                 .read()
                 .unwrap()
-                .find_swapcoin(&receivers_contract_tx_info.multisig_redeemscript)
-                .ok_or(Error::Protocol("multisig_redeemscript not found"))?
-                .sign_contract_tx_with_my_privkey(&receivers_contract_tx_info.contract_tx)?,
+                .find_incoming_swapcoin(&receivers_contract_tx_info.multisig_redeemscript)
+            {
+                c.sign_contract_tx_with_my_privkey(&receivers_contract_tx_info.contract_tx)?
+            } else {
+                wallet
+                    .read()
+                    .unwrap()
+                    .find_outgoing_swapcoin(&receivers_contract_tx_info.multisig_redeemscript)
+                    .ok_or(Error::Protocol("multisig_redeemscript not found"))?
+                    .sign_contract_tx_with_my_privkey(&receivers_contract_tx_info.contract_tx)?
+            },
         );
     }
     Ok(Some(MakerToTakerMessage::ReceiversContractSig(
@@ -608,7 +616,7 @@ fn handle_hash_preimage(
         let mut wallet_mref = wallet.write().unwrap();
         for multisig_redeemscript in message.senders_multisig_redeemscripts {
             let mut incoming_swapcoin = wallet_mref
-                .find_swapcoin_mut(&multisig_redeemscript)
+                .find_incoming_swapcoin_mut(&multisig_redeemscript)
                 .ok_or(Error::Protocol("senders multisig_redeemscript not found"))?;
             if read_hashvalue_from_contract(&incoming_swapcoin.contract_redeemscript)
                 .map_err(|_| Error::Protocol("unable to read hashvalue from contract"))?
@@ -624,7 +632,7 @@ fn handle_hash_preimage(
     let mut swapcoin_private_keys = Vec::<SwapCoinPrivateKey>::new();
     for multisig_redeemscript in message.receivers_multisig_redeemscripts {
         let outgoing_swapcoin = wallet_ref
-            .find_swapcoin(&multisig_redeemscript)
+            .find_outgoing_swapcoin(&multisig_redeemscript)
             .ok_or(Error::Protocol("receivers multisig_redeemscript not found"))?;
         if read_hashvalue_from_contract(&outgoing_swapcoin.contract_redeemscript)
             .map_err(|_| Error::Protocol("unable to read hashvalue from contract"))?
@@ -652,10 +660,16 @@ fn handle_private_key_handover(
 ) -> Result<Option<MakerToTakerMessage>, Error> {
     let mut wallet_ref = wallet.write().unwrap();
     for swapcoin_private_key in message.swapcoin_private_keys {
-        wallet_ref
-            .find_swapcoin_mut(&swapcoin_private_key.multisig_redeemscript)
-            .ok_or(Error::Protocol("multisig_redeemscript not found"))?
-            .apply_privkey(swapcoin_private_key.key)?
+        if let Some(c) =
+            wallet_ref.find_incoming_swapcoin_mut(&swapcoin_private_key.multisig_redeemscript)
+        {
+            c.apply_privkey(swapcoin_private_key.key)?
+        } else {
+            wallet_ref
+                .find_outgoing_swapcoin_mut(&swapcoin_private_key.multisig_redeemscript)
+                .ok_or(Error::Protocol("multisig_redeemscript not found"))?
+                .apply_privkey(swapcoin_private_key.key)?
+        }
     }
     wallet_ref.update_swap_coins_list()?;
     println!("successfully completed coinswap");
diff --git a/src/messages.rs b/src/messages.rs
index 9880ea9c..5b3df3dc 100644
--- a/src/messages.rs
+++ b/src/messages.rs
@@ -6,7 +6,7 @@
 
 use serde::{Deserialize, Serialize};
 
-use bitcoin::hashes::hash160::Hash as Hash160;
+use bitcoin::hashes::{hash160::Hash as Hash160, sha256::Hash as Hash256};
 use bitcoin::secp256k1::{SecretKey, Signature};
 use bitcoin::util::key::PublicKey;
 use bitcoin::{Script, Transaction};
@@ -86,7 +86,7 @@ pub struct SignReceiversContractTx {
 pub struct HashPreimage {
     pub senders_multisig_redeemscripts: Vec<Script>,
     pub receivers_multisig_redeemscripts: Vec<Script>,
-    pub preimage: [u8; 32],
+    pub preimage: Hash256,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
diff --git a/src/taker_protocol.rs b/src/taker_protocol.rs
index db82b7fb..8f4036d9 100644
--- a/src/taker_protocol.rs
+++ b/src/taker_protocol.rs
@@ -9,7 +9,7 @@ use tokio::prelude::*;
 use tokio::time::sleep;
 
 use bitcoin::consensus::encode::deserialize;
-use bitcoin::hashes::hash160::Hash as Hash160;
+use bitcoin::hashes::{hash160::Hash as Hash160, sha256::Hash as Hash256};
 use bitcoin::hashes::{hex::ToHex, Hash};
 use bitcoin::secp256k1::{SecretKey, Signature};
 use bitcoin::util::key::PublicKey;
@@ -40,7 +40,9 @@ use crate::messages::{
 use crate::get_bitcoin_rpc;
 
 use crate::offerbook_sync::{sync_offerbook, OfferAddress};
-use crate::wallet_sync::{generate_keypair, CoreAddressLabelType, Wallet, WalletSwapCoin};
+use crate::wallet_sync::{
+    generate_keypair, CoreAddressLabelType, IncomingSwapCoin, OutgoingSwapCoin, Wallet,
+};
 
 #[tokio::main]
 pub async fn start_taker(rpc: &Client, wallet: &mut Wallet) {
@@ -71,6 +73,7 @@ async fn send_coinswap(
     let mut preimage = [0u8; 32];
     OsRng.fill_bytes(&mut preimage);
     let hashvalue = Hash160::hash(&preimage);
+    let preimage = Hash256::from_inner(preimage);
 
     let first_swap_locktime = REFUND_LOCKTIME + REFUND_LOCKTIME_STEP * maker_count;
 
@@ -112,7 +115,7 @@ async fn send_coinswap(
         .for_each(|(sig, outgoing_swapcoin)| outgoing_swapcoin.others_contract_sig = Some(*sig));
 
     for outgoing_swapcoin in &outgoing_swapcoins {
-        wallet.add_swapcoin(outgoing_swapcoin.clone());
+        wallet.add_outgoing_swapcoin(outgoing_swapcoin.clone());
     }
     wallet.update_swap_coins_list().unwrap();
 
@@ -132,7 +135,7 @@ async fn send_coinswap(
     let mut active_maker_addresses = Vec::<String>::new();
     let mut previous_maker: Option<OfferAddress> = None;
     let mut watchonly_swapcoins = Vec::<Vec<WatchOnlySwapCoin>>::new();
-    let mut incoming_swapcoins = Vec::<WalletSwapCoin>::new();
+    let mut incoming_swapcoins = Vec::<IncomingSwapCoin>::new();
 
     for maker_index in 0..maker_count {
         let maker = maker_offers_addresses.pop().unwrap();
@@ -289,7 +292,7 @@ async fn send_coinswap(
         incoming_swapcoin.others_contract_sig = Some(receiver_contract_sig);
     }
     for incoming_swapcoin in &incoming_swapcoins {
-        wallet.add_swapcoin(incoming_swapcoin.clone());
+        wallet.add_incoming_swapcoin(incoming_swapcoin.clone());
     }
     wallet.update_swap_coins_list().unwrap();
 
@@ -387,7 +390,7 @@ async fn send_coinswap(
     //update incoming_swapcoins with privkey on disk here
     for incoming_swapcoin in &incoming_swapcoins {
         wallet
-            .find_swapcoin_mut(&incoming_swapcoin.get_multisig_redeemscript())
+            .find_incoming_swapcoin_mut(&incoming_swapcoin.get_multisig_redeemscript())
             .unwrap()
             .other_privkey = incoming_swapcoin.other_privkey;
     }
@@ -825,7 +828,7 @@ async fn send_proof_of_funding_and_get_contract_txes(
 
 fn sign_receivers_contract_txes(
     receivers_contract_txes: &[Transaction],
-    outgoing_swapcoins: &[WalletSwapCoin],
+    outgoing_swapcoins: &[OutgoingSwapCoin],
 ) -> Result<Vec<Signature>, Error> {
     receivers_contract_txes
         .iter()
@@ -906,8 +909,8 @@ fn create_incoming_swapcoins(
     next_peer_hashlock_keys_or_nonces: &[SecretKey],
     next_peer_multisig_pubkeys: &[PublicKey],
     next_peer_multisig_keys_or_nonces: &[SecretKey],
-    preimage: [u8; 32],
-) -> Result<Vec<WalletSwapCoin>, Error> {
+    preimage: Hash256,
+) -> Result<Vec<IncomingSwapCoin>, Error> {
     let next_swap_multisig_redeemscripts = maker_sign_sender_and_receiver_contracts
         .senders_contract_txes_info
         .iter()
@@ -948,7 +951,7 @@ fn create_incoming_swapcoins(
     )
     .collect::<Vec<Transaction>>();
 
-    let mut incoming_swapcoins = Vec::<WalletSwapCoin>::new();
+    let mut incoming_swapcoins = Vec::<IncomingSwapCoin>::new();
     for (
         multisig_redeemscript,
         &maker_funded_multisig_pubkey,
@@ -978,7 +981,7 @@ fn create_incoming_swapcoins(
             o_ms_pubkey1
         };
 
-        let mut incoming_swapcoin = WalletSwapCoin::new(
+        let mut incoming_swapcoin = IncomingSwapCoin::new(
             maker_funded_multisig_privkey,
             maker_funded_other_multisig_pubkey,
             my_receivers_contract_tx.clone(),
@@ -1005,7 +1008,7 @@ async fn send_hash_preimage_and_get_private_keys(
     socket_writer: &mut WriteHalf<'_>,
     senders_multisig_redeemscripts: Vec<Script>,
     receivers_multisig_redeemscripts: Vec<Script>,
-    preimage: [u8; 32],
+    preimage: Hash256,
 ) -> Result<PrivateKeyHandover, Error> {
     let receivers_multisig_redeemscripts_len = receivers_multisig_redeemscripts.len();
     send_message(
diff --git a/src/wallet_sync.rs b/src/wallet_sync.rs
index 4008e923..e0329fa0 100644
--- a/src/wallet_sync.rs
+++ b/src/wallet_sync.rs
@@ -24,6 +24,7 @@ use bitcoin::{
     hashes::{
         hash160::Hash as Hash160,
         hex::{FromHex, ToHex},
+        sha256::Hash as Hash256,
     },
     secp256k1,
     secp256k1::{Secp256k1, SecretKey, Signature},
@@ -74,7 +75,8 @@ struct WalletFileData {
     seedphrase: String,
     extension: String,
     external_index: u32,
-    swap_coins: Vec<WalletSwapCoin>,
+    incoming_swap_coins: Vec<IncomingSwapCoin>,
+    outgoing_swap_coins: Vec<OutgoingSwapCoin>,
     prevout_to_contract_map: HashMap<OutPoint, Script>,
 }
 
@@ -82,7 +84,8 @@ pub struct Wallet {
     master_key: ExtendedPrivKey,
     wallet_file_name: String,
     external_index: u32,
-    swap_coins: HashMap<Script, WalletSwapCoin>,
+    incoming_swap_coins: HashMap<Script, IncomingSwapCoin>,
+    outgoing_swap_coins: HashMap<Script, OutgoingSwapCoin>,
 }
 
 pub enum CoreAddressLabelType {
@@ -94,56 +97,124 @@ const WATCH_ONLY_SWAPCOIN_LABEL: &str = "watchonly_swapcoin_label";
 //swapcoins are UTXOs + metadata which are not from the deterministic wallet
 //they are made in the process of a coinswap
 #[derive(serde::Serialize, serde::Deserialize, Debug, Clone)]
-pub struct WalletSwapCoin {
+pub struct IncomingSwapCoin {
     pub my_privkey: SecretKey,
     pub other_pubkey: PublicKey,
     pub other_privkey: Option<SecretKey>,
     pub contract_tx: Transaction,
     pub contract_redeemscript: Script,
-    //either timelock_privkey for outgoing swapcoins or hashlock_privkey for incoming swapcoins
-    pub contract_privkey: SecretKey,
+    pub hashlock_privkey: SecretKey,
     pub funding_amount: u64,
     pub others_contract_sig: Option<Signature>,
-    pub hash_preimage: Option<[u8; 32]>,
+    pub hash_preimage: Option<Hash256>,
 }
-//TODO split WalletSwapCoin into two structs, IncomingSwapCoin and OutgoingSwapCoin
-//where Incoming has hashlock_privkey and Outgoing has timelock_privkey
-//that is a much more rustic way of doing things, which uses the compiler to check for some bugs
 
-impl WalletSwapCoin {
+//swapcoins are UTXOs + metadata which are not from the deterministic wallet
+//they are made in the process of a coinswap
+#[derive(serde::Serialize, serde::Deserialize, Debug, Clone)]
+pub struct OutgoingSwapCoin {
+    pub my_privkey: SecretKey,
+    pub other_pubkey: PublicKey,
+    pub contract_tx: Transaction,
+    pub contract_redeemscript: Script,
+    pub timelock_privkey: SecretKey,
+    pub funding_amount: u64,
+    pub others_contract_sig: Option<Signature>,
+    pub hash_preimage: Option<Hash256>,
+}
+
+impl IncomingSwapCoin {
     pub fn new(
         my_privkey: SecretKey,
         other_pubkey: PublicKey,
         contract_tx: Transaction,
         contract_redeemscript: Script,
-        contract_privkey: SecretKey,
+        hashlock_privkey: SecretKey,
         funding_amount: u64,
-    ) -> WalletSwapCoin {
+    ) -> Self {
         let secp = Secp256k1::new();
-        let contract_pubkey = PublicKey {
+        let hashlock_pubkey = PublicKey {
             compressed: true,
-            key: secp256k1::PublicKey::from_secret_key(&secp, &contract_privkey),
+            key: secp256k1::PublicKey::from_secret_key(&secp, &hashlock_privkey),
         };
         assert!(
-            contract_pubkey
+            hashlock_pubkey
                 == contracts::read_hashlock_pubkey_from_contract(&contract_redeemscript).unwrap()
-                || contract_pubkey
-                    == contracts::read_timelock_pubkey_from_contract(&contract_redeemscript)
-                        .unwrap()
         );
-        WalletSwapCoin {
+        Self {
             my_privkey,
             other_pubkey,
             other_privkey: None,
             contract_tx,
             contract_redeemscript,
-            contract_privkey,
+            hashlock_privkey,
+            funding_amount,
+            others_contract_sig: None,
+            hash_preimage: None,
+        }
+    }
+
+    pub fn type_string(&self) -> &str {
+        "hashlock"
+    }
+
+    pub fn contract_privkey_is_known(&self) -> bool {
+        self.other_privkey.is_some() || self.hash_preimage.is_some()
+    }
+}
+
+impl OutgoingSwapCoin {
+    pub fn new(
+        my_privkey: SecretKey,
+        other_pubkey: PublicKey,
+        contract_tx: Transaction,
+        contract_redeemscript: Script,
+        timelock_privkey: SecretKey,
+        funding_amount: u64,
+    ) -> Self {
+        let secp = Secp256k1::new();
+        let timelock_pubkey = PublicKey {
+            compressed: true,
+            key: secp256k1::PublicKey::from_secret_key(&secp, &timelock_privkey),
+        };
+        assert!(
+            timelock_pubkey
+                == contracts::read_timelock_pubkey_from_contract(&contract_redeemscript).unwrap()
+        );
+        Self {
+            my_privkey,
+            other_pubkey,
+            contract_tx,
+            contract_redeemscript,
+            timelock_privkey,
             funding_amount,
             others_contract_sig: None,
             hash_preimage: None,
         }
     }
 
+    pub fn type_string(&self) -> &str {
+        "timelock"
+    }
+
+    pub fn contract_privkey_is_known(&self) -> bool {
+        self.hash_preimage.is_some()
+    }
+}
+
+pub trait WalletSwapCoin {
+    fn get_my_pubkey(&self) -> PublicKey;
+    fn get_other_pubkey(&self) -> &PublicKey;
+    fn sign_transaction_input(
+        &self,
+        index: usize,
+        tx: &Transaction,
+        input: &mut TxIn,
+        redeemscript: &Script,
+    ) -> Result<(), &'static str>;
+}
+
+impl WalletSwapCoin for IncomingSwapCoin {
     fn get_my_pubkey(&self) -> PublicKey {
         let secp = Secp256k1::new();
         PublicKey {
@@ -152,6 +223,10 @@ impl WalletSwapCoin {
         }
     }
 
+    fn get_other_pubkey(&self) -> &PublicKey {
+        &self.other_pubkey
+    }
+
     fn sign_transaction_input(
         &self,
         index: usize,
@@ -195,26 +270,80 @@ impl WalletSwapCoin {
     }
 }
 
+impl WalletSwapCoin for OutgoingSwapCoin {
+    fn get_my_pubkey(&self) -> PublicKey {
+        let secp = Secp256k1::new();
+        PublicKey {
+            compressed: true,
+            key: secp256k1::PublicKey::from_secret_key(&secp, &self.my_privkey),
+        }
+    }
+
+    fn get_other_pubkey(&self) -> &PublicKey {
+        &self.other_pubkey
+    }
+
+    fn sign_transaction_input(
+        &self,
+        index: usize,
+        tx: &Transaction,
+        input: &mut TxIn,
+        redeemscript: &Script,
+    ) -> Result<(), &'static str> {
+        let secp = Secp256k1::new();
+
+        let sighash = secp256k1::Message::from_slice(
+            &SigHashCache::new(tx).signature_hash(
+                index,
+                redeemscript,
+                self.funding_amount,
+                SigHashType::All,
+            )[..],
+        )
+        .unwrap();
+
+        let sig = secp.sign(&sighash, &self.my_privkey);
+
+        input.witness.push(Vec::new()); //first is multisig dummy
+        input.witness.push(sig.serialize_der().to_vec());
+        input.witness[1].push(SigHashType::All as u8);
+        input.witness.push(redeemscript.to_bytes());
+        Ok(())
+    }
+}
+
 impl Wallet {
     pub fn print_wallet_key_data(&self) {
         println!(
             "master key = {}, external_index = {}",
             self.master_key, self.external_index
         );
-        for (multisig_redeemscript, swapcoin) in &self.swap_coins {
-            println!(
-                "{} {}:{} {}",
-                Address::p2wsh(multisig_redeemscript, NETWORK),
-                swapcoin.contract_tx.input[0].previous_output.txid,
-                swapcoin.contract_tx.input[0].previous_output.vout,
-                if swapcoin.other_privkey.is_some() {
-                    "  known"
-                } else {
-                    "unknown"
-                }
-            )
+
+        for (multisig_redeemscript, swapcoin) in &self.incoming_swap_coins {
+            Self::print_script_and_coin(multisig_redeemscript, swapcoin);
         }
-        println!("swapcoin count = {}", self.swap_coins.len());
+        for (multisig_redeemscript, swapcoin) in &self.outgoing_swap_coins {
+            Self::print_script_and_coin(multisig_redeemscript, swapcoin);
+        }
+        println!(
+            "swapcoin count = {}",
+            self.incoming_swap_coins.len() + self.outgoing_swap_coins.len()
+        );
+    }
+
+    fn print_script_and_coin(script: &Script, coin: &dyn SwapCoin) {
+        let contract_tx = coin.get_contract_tx();
+        println!(
+            "{} {}:{} {}",
+            Address::p2wsh(script, NETWORK),
+            contract_tx.input[0].previous_output.txid,
+            contract_tx.input[0].previous_output.vout,
+            if coin.is_known() {
+                "  known"
+            } else {
+                "unknown"
+            }
+        )
     }
 
     pub fn save_new_wallet_file<P: AsRef<Path>>(
@@ -227,7 +356,8 @@ impl Wallet {
             seedphrase,
             extension,
             external_index: 0,
-            swap_coins: Vec::new(),
+            incoming_swap_coins: Vec::new(),
+            outgoing_swap_coins: Vec::new(),
             prevout_to_contract_map: HashMap::<OutPoint, Script>::new(),
         };
         let wallet_file = File::create(wallet_file_name)?;
@@ -267,11 +397,16 @@ impl Wallet {
             master_key: xprv,
             wallet_file_name,
             external_index: wallet_file_data.external_index,
-            swap_coins: wallet_file_data
-                .swap_coins
+            incoming_swap_coins: wallet_file_data
+                .incoming_swap_coins
+                .iter()
+                .map(|sc| (sc.get_multisig_redeemscript(), sc.clone()))
+                .collect::<HashMap<Script, IncomingSwapCoin>>(),
+            outgoing_swap_coins: wallet_file_data
+                .outgoing_swap_coins
                 .iter()
                 .map(|sc| (sc.get_multisig_redeemscript(), sc.clone()))
-                .collect::<HashMap<Script, WalletSwapCoin>>(),
+                .collect::<HashMap<Script, OutgoingSwapCoin>>(),
         };
         Ok(wallet)
     }
@@ -292,35 +427,62 @@ impl Wallet {
 
     pub fn update_swap_coins_list(&self) -> Result<(), Error> {
         let mut wallet_file_data = Wallet::load_wallet_file_data(&self.wallet_file_name)?;
-        wallet_file_data.swap_coins = self
-            .swap_coins
+        wallet_file_data.incoming_swap_coins = self
+            .incoming_swap_coins
+            .values()
+            .cloned()
+            .collect::<Vec<IncomingSwapCoin>>();
+        wallet_file_data.outgoing_swap_coins = self
+            .outgoing_swap_coins
             .values()
             .cloned()
-            .collect::<Vec<WalletSwapCoin>>();
+            .collect::<Vec<OutgoingSwapCoin>>();
         let wallet_file = File::create(&self.wallet_file_name[..])?;
         serde_json::to_writer(wallet_file, &wallet_file_data).map_err(|e| io::Error::from(e))?;
         Ok(())
     }
 
-    pub fn find_swapcoin(&self, multisig_redeemscript: &Script) -> Option<&WalletSwapCoin> {
-        self.swap_coins.get(multisig_redeemscript)
+    pub fn find_incoming_swapcoin(
+        &self,
+        multisig_redeemscript: &Script,
+    ) -> Option<&IncomingSwapCoin> {
+        self.incoming_swap_coins.get(multisig_redeemscript)
+    }
+
+    pub fn find_outgoing_swapcoin(
+        &self,
+        multisig_redeemscript: &Script,
+    ) -> Option<&OutgoingSwapCoin> {
+        self.outgoing_swap_coins.get(multisig_redeemscript)
     }
 
-    pub fn find_swapcoin_mut(
+    pub fn find_incoming_swapcoin_mut(
         &mut self,
         multisig_redeemscript: &Script,
-    ) -> Option<&mut WalletSwapCoin> {
-        self.swap_coins.get_mut(multisig_redeemscript)
+    ) -> Option<&mut IncomingSwapCoin> {
+        self.incoming_swap_coins.get_mut(multisig_redeemscript)
     }
 
-    pub fn add_swapcoin(&mut self, coin: WalletSwapCoin) {
-        self.swap_coins
+    pub fn find_outgoing_swapcoin_mut(
+        &mut self,
+        multisig_redeemscript: &Script,
+    ) -> Option<&mut OutgoingSwapCoin> {
+        self.outgoing_swap_coins.get_mut(multisig_redeemscript)
+    }
+
+    pub fn add_incoming_swapcoin(&mut self, coin: IncomingSwapCoin) {
+        self.incoming_swap_coins
+            .insert(coin.get_multisig_redeemscript(), coin);
+    }
+
+    pub fn add_outgoing_swapcoin(&mut self, coin: OutgoingSwapCoin) {
+        self.outgoing_swap_coins
             .insert(coin.get_multisig_redeemscript(), coin);
     }
 
     #[cfg(test)]
     pub fn get_swap_coins_count(&self) -> usize {
-        self.swap_coins.len()
+        self.incoming_swap_coins.len() + self.outgoing_swap_coins.len()
     }
 
     //this function is used in two places
@@ -484,13 +646,13 @@ impl Wallet {
             .filter(|d| !self.is_xpub_descriptor_imported(rpc, &d).unwrap())
             .collect::<Vec<&String>>();
 
-        let swapcoin_descriptors_to_import = self
-            .swap_coins
+        let mut swapcoin_descriptors_to_import = self
+            .incoming_swap_coins
             .values()
             .map(|sc| {
                 format!(
                     "wsh(sortedmulti(2,{},{}))",
-                    sc.other_pubkey,
+                    sc.get_other_pubkey(),
                     sc.get_my_pubkey()
                 )
             })
@@ -498,6 +660,20 @@ impl Wallet {
             .filter(|d| !self.is_swapcoin_descriptor_imported(rpc, &d))
             .collect::<Vec<String>>();
 
+        swapcoin_descriptors_to_import.extend(
+            self.outgoing_swap_coins
+                .values()
+                .map(|sc| {
+                    format!(
+                        "wsh(sortedmulti(2,{},{}))",
+                        sc.get_other_pubkey(),
+                        sc.get_my_pubkey()
+                    )
+                })
+                .map(|d| rpc.get_descriptor_info(&d).unwrap().descriptor)
+                .filter(|d| !self.is_swapcoin_descriptor_imported(rpc, &d)),
+        );
+
         if hd_descriptors_to_import.is_empty() && swapcoin_descriptors_to_import.is_empty() {
             return Ok(());
         }
@@ -563,12 +739,19 @@ impl Wallet {
             fingerprint == master_private_key.fingerprint(&secp).to_string()
         } else {
             //utxo might be one of our swapcoins
-            self.find_swapcoin(
+            self.find_incoming_swapcoin(
                 u.witness_script
                     .as_ref()
                     .unwrap_or(&Script::from(Vec::from_hex("").unwrap())),
             )
             .map_or(false, |sc| sc.other_privkey.is_some())
+                || self
+                    .find_outgoing_swapcoin(
+                        u.witness_script
+                            .as_ref()
+                            .unwrap_or(&Script::from(Vec::from_hex("").unwrap())),
+                    )
+                    .map_or(false, |sc| sc.hash_preimage.is_some())
         }
     }
 
@@ -607,20 +790,45 @@ impl Wallet {
     pub fn find_incomplete_coinswaps(
         &self,
         rpc: &Client,
-    ) -> Result<HashMap<Hash160, Vec<(ListUnspentResultEntry, &WalletSwapCoin)>>, Error> {
+    ) -> Result<
+        HashMap<
+            Hash160,
+            (
+                Vec<(ListUnspentResultEntry, &IncomingSwapCoin)>,
+                Vec<(ListUnspentResultEntry, &OutgoingSwapCoin)>,
+            ),
+        >,
+        Error,
+    > {
         rpc.call::<Value>("lockunspent", &[Value::Bool(true)])
             .map_err(|e| Error::Rpc(e))?;
 
         let completed_coinswap_hashvalues = self
-            .swap_coins
+            .incoming_swap_coins
             .values()
             .filter(|sc| sc.other_privkey.is_some())
             .map(|sc| read_hashvalue_from_contract(&sc.contract_redeemscript).unwrap())
             .collect::<HashSet<Hash160>>();
         //TODO make this read_hashvalue_from_contract() a struct function of WalletCoinSwap
 
-        let mut incomplete_swapcoin_groups =
-            HashMap::<Hash160, Vec<(ListUnspentResultEntry, &WalletSwapCoin)>>::new();
+        let mut incomplete_swapcoin_groups = HashMap::<
+            Hash160,
+            (
+                Vec<(ListUnspentResultEntry, &IncomingSwapCoin)>,
+                Vec<(ListUnspentResultEntry, &OutgoingSwapCoin)>,
+            ),
+        >::new();
+        let get_hashvalue = |s: &dyn SwapCoin| {
+            if s.is_known() {
+                return None;
+            }
+            let swapcoin_hashvalue = read_hashvalue_from_contract(&s.get_contract_redeemscript())
+                .expect("unable to read hashvalue from contract_redeemscript");
+            if completed_coinswap_hashvalues.contains(&swapcoin_hashvalue) {
+                return None;
+            }
+            Some(swapcoin_hashvalue)
+        };
         for utxo in rpc.list_unspent(None, None, None, None, None)? {
             if utxo.descriptor.is_none() {
                 continue;
@@ -630,23 +838,31 @@ impl Wallet {
             } else {
                 continue;
             };
-            let swapcoin = if let Some(s) = self.find_swapcoin(multisig_redeemscript) {
-                s
+            if let Some(s) = self.find_incoming_swapcoin(multisig_redeemscript) {
+                if let Some(swapcoin_hashvalue) = get_hashvalue(s) {
+                    incomplete_swapcoin_groups
+                        .entry(swapcoin_hashvalue)
+                        .or_insert((
+                            Vec::<(ListUnspentResultEntry, &IncomingSwapCoin)>::new(),
+                            Vec::<(ListUnspentResultEntry, &OutgoingSwapCoin)>::new(),
+                        ))
+                        .0
+                        .push((utxo, s));
+                }
+            } else if let Some(s) = self.find_outgoing_swapcoin(multisig_redeemscript) {
+                if let Some(swapcoin_hashvalue) = get_hashvalue(s) {
+                    incomplete_swapcoin_groups
+                        .entry(swapcoin_hashvalue)
+                        .or_insert((
+                            Vec::<(ListUnspentResultEntry, &IncomingSwapCoin)>::new(),
+                            Vec::<(ListUnspentResultEntry, &OutgoingSwapCoin)>::new(),
+                        ))
+                        .1
+                        .push((utxo, s));
+                }
             } else {
                 continue;
             };
-            if swapcoin.other_privkey.is_some() {
-                continue;
-            }
-            let swapcoin_hashvalue = read_hashvalue_from_contract(&swapcoin.contract_redeemscript)
-                .expect("unable to read hashvalue from contract_redeemscript");
-            if completed_coinswap_hashvalues.contains(&swapcoin_hashvalue) {
-                continue;
-            }
-            incomplete_swapcoin_groups
-                .entry(swapcoin_hashvalue)
-                .or_insert(Vec::<(ListUnspentResultEntry, &WalletSwapCoin)>::new())
-                .push((utxo, swapcoin));
         }
         Ok(incomplete_swapcoin_groups)
     }
@@ -752,7 +968,7 @@ impl Wallet {
                 )
                 .into_script();
 
-                self.find_swapcoin(&redeemscript)
+                self.find_outgoing_swapcoin(&redeemscript)
                     .unwrap()
                     .sign_transaction_input(ix, &tx_clone, &mut input, &redeemscript)
                     .unwrap();
@@ -1059,7 +1275,7 @@ impl Wallet {
         hashlock_pubkeys: &[PublicKey],
         hashvalue: Hash160,
         locktime: u16, //returns: funding_txes, swapcoins, timelock_pubkeys
-    ) -> Result<(Vec<Transaction>, Vec<WalletSwapCoin>, Vec<PublicKey>), Error> {
+    ) -> Result<(Vec<Transaction>, Vec<OutgoingSwapCoin>, Vec<PublicKey>), Error> {
         let (coinswap_addresses, my_multisig_privkeys): (Vec<_>, Vec<_>) = other_multisig_pubkeys
             .iter()
             .map(|other_key| self.create_and_import_coinswap_address(rpc, other_key))
@@ -1073,7 +1289,7 @@ impl Wallet {
         // an integer but also can be Sweep
 
         let mut timelock_pubkeys = Vec::<PublicKey>::new();
-        let mut outgoing_swapcoins = Vec::<WalletSwapCoin>::new();
+        let mut outgoing_swapcoins = Vec::<OutgoingSwapCoin>::new();
 
         for (
             my_funding_tx,
@@ -1107,7 +1323,7 @@ impl Wallet {
             );
 
             timelock_pubkeys.push(timelock_pubkey);
-            outgoing_swapcoins.push(WalletSwapCoin::new(
+            outgoing_swapcoins.push(OutgoingSwapCoin::new(
                 my_multisig_privkey,
                 other_multisig_pubkey,
                 my_senders_contract_tx,