Archives
/
xmr-btc-swap
mirror of https://github.com/comit-network/xmr-btc-swap
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

Merge 82cbea4918 into 2b850924b1

Browse Source
pull/1420/merge
pokkst 3 weeks ago committed by GitHub
parent 2b850924b1 82cbea4918
commit 1adc5ee3d5
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
5 changed files with 103 additions and 40 deletions
Show Stats Download Patch File Download Diff File

17
swap/src/asb/network.rs
Unescape Escape View File

@ -30,14 +30,27 @@ use uuid::Uuid;
pub mod transport {
use super::*;
use crate::network::tor_transport::TorDialOnlyTransport;
use libp2p::core::transport::OptionalTransport;
/// Creates the libp2p transport for the ASB.
pub fn new(identity: &identity::Keypair) -> Result<Boxed<(PeerId, StreamMuxerBox)>> {
pub fn new(
identity: &identity::Keypair,
maybe_tor_socks5_port: Option<u16>,
) -> Result<Boxed<(PeerId, StreamMuxerBox)>> {
let tcp = TokioTcpConfig::new().nodelay(true);
let tcp_with_dns = TokioDnsConfig::system(tcp)?;
let websocket_with_dns = WsConfig::new(tcp_with_dns.clone());
let transport = tcp_with_dns.or_transport(websocket_with_dns).boxed();
let maybe_tor_transport = match maybe_tor_socks5_port {
Some(port) => OptionalTransport::some(TorDialOnlyTransport::new(port)),
None => OptionalTransport::none(),
};
let transport = maybe_tor_transport
.or_transport(tcp_with_dns)
.or_transport(websocket_with_dns)
.boxed();
authenticate_and_multiplex(transport, identity)
}

77
swap/src/bin/asb.rs
Unescape Escape View File

@ -100,6 +100,36 @@ async fn main() -> Result<()> {
let seed =
Seed::from_file_or_generate(&config.data.dir).expect("Could not retrieve/initialize seed");
let tor_client =
tor::Client::new(config.tor.socks5_port).with_control_port(config.tor.control_port);
let _ac = match tor_client.assert_tor_running().await {
Ok(_) => {
tracing::info!("Setting up Tor hidden service");
let ac =
register_tor_services(config.network.clone().listen, tor_client, &seed).await?;
Some(ac)
}
Err(_) => {
tracing::warn!("Tor not found. Running on clear net");
None
}
};
let tor_port = if _ac.is_some() {
config.tor.socks5_port
} else {
0u16
};
let proxy_string = if tor_port != 0u16 {
format!("127.0.0.1:{}", tor_port)
} else {
"".to_string()
};
if proxy_string.is_empty() {
tracing::info!(%proxy_string, "Not using SOCKS5 proxy");
} else {
tracing::info!(%proxy_string, "Using SOCKS5 proxy at");
}
match cmd {
Command::Start { resume_only } => {
// check and warn for duplicate rendezvous points
@ -140,29 +170,13 @@ async fn main() -> Result<()> {
}
}
let bitcoin_wallet = init_bitcoin_wallet(&config, &seed, env_config).await?;
let bitcoin_wallet =
init_bitcoin_wallet(&config, &seed, env_config, proxy_string).await?;
let bitcoin_balance = bitcoin_wallet.balance().await?;
tracing::info!(%bitcoin_balance, "Bitcoin wallet balance");
let kraken_price_updates = kraken::connect(config.maker.price_ticker_ws_url.clone())?;
// setup Tor hidden services
let tor_client =
tor::Client::new(config.tor.socks5_port).with_control_port(config.tor.control_port);
let _ac = match tor_client.assert_tor_running().await {
Ok(_) => {
tracing::info!("Setting up Tor hidden service");
let ac =
register_tor_services(config.network.clone().listen, tor_client, &seed)
.await?;
Some(ac)
}
Err(_) => {
tracing::warn!("Tor not found. Running on clear net");
None
}
};
let kraken_rate = KrakenRate::new(config.maker.ask_spread, kraken_price_updates);
let namespace = XmrBtcNamespace::from_is_testnet(testnet);
@ -175,7 +189,9 @@ async fn main() -> Result<()> {
env_config,
namespace,
&rendezvous_addrs,
)?;
tor_port,
)
.await?;
for listen in config.network.listen.clone() {
Swarm::listen_on(&mut swarm, listen.clone())
@ -241,7 +257,8 @@ async fn main() -> Result<()> {
println!("{}", config_json);
}
Command::WithdrawBtc { amount, address } => {
let bitcoin_wallet = init_bitcoin_wallet(&config, &seed, env_config).await?;
let bitcoin_wallet =
init_bitcoin_wallet(&config, &seed, env_config, proxy_string).await?;
let amount = match amount {
Some(amount) => amount,
@ -264,20 +281,23 @@ async fn main() -> Result<()> {
let monero_balance = monero_wallet.get_balance().await?;
tracing::info!(%monero_balance);
let bitcoin_wallet = init_bitcoin_wallet(&config, &seed, env_config).await?;
let bitcoin_wallet =
init_bitcoin_wallet(&config, &seed, env_config, proxy_string).await?;
let bitcoin_balance = bitcoin_wallet.balance().await?;
tracing::info!(%bitcoin_balance);
tracing::info!(%bitcoin_balance, %monero_balance, "Current balance");
}
Command::Cancel { swap_id } => {
let bitcoin_wallet = init_bitcoin_wallet(&config, &seed, env_config).await?;
let bitcoin_wallet =
init_bitcoin_wallet(&config, &seed, env_config, proxy_string).await?;
let (txid, _) = cancel(swap_id, Arc::new(bitcoin_wallet), db).await?;
tracing::info!("Cancel transaction successfully published with id {}", txid);
}
Command::Refund { swap_id } => {
let bitcoin_wallet = init_bitcoin_wallet(&config, &seed, env_config).await?;
let bitcoin_wallet =
init_bitcoin_wallet(&config, &seed, env_config, proxy_string).await?;
let monero_wallet = init_monero_wallet(&config, env_config).await?;
refund(
@ -291,7 +311,8 @@ async fn main() -> Result<()> {
tracing::info!("Monero successfully refunded");
}
Command::Punish { swap_id } => {
let bitcoin_wallet = init_bitcoin_wallet(&config, &seed, env_config).await?;
let bitcoin_wallet =
init_bitcoin_wallet(&config, &seed, env_config, proxy_string).await?;
let (txid, _) = punish(swap_id, Arc::new(bitcoin_wallet), db).await?;
@ -306,7 +327,8 @@ async fn main() -> Result<()> {
swap_id,
do_not_await_finality,
} => {
let bitcoin_wallet = init_bitcoin_wallet(&config, &seed, env_config).await?;
let bitcoin_wallet =
init_bitcoin_wallet(&config, &seed, env_config, proxy_string).await?;
let (txid, _) = redeem(
swap_id,
@ -319,7 +341,8 @@ async fn main() -> Result<()> {
tracing::info!("Redeem transaction successfully published with id {}", txid);
}
Command::ExportBitcoinWallet => {
let bitcoin_wallet = init_bitcoin_wallet(&config, &seed, env_config).await?;
let bitcoin_wallet =
init_bitcoin_wallet(&config, &seed, env_config, proxy_string).await?;
let wallet_export = bitcoin_wallet.wallet_export("asb").await?;
println!("{}", wallet_export.to_string())
}
@ -332,11 +355,13 @@ async fn init_bitcoin_wallet(
config: &Config,
seed: &Seed,
env_config: swap::env::Config,
proxy_string: String,
) -> Result<bitcoin::Wallet> {
tracing::debug!("Opening Bitcoin wallet");
let data_dir = &config.data.dir;
let wallet = bitcoin::Wallet::new(
config.bitcoin.electrum_rpc_url.clone(),
proxy_string.as_str(),
data_dir,
seed.derive_extended_private_key(env_config.bitcoin_network)?,
env_config,

1
swap/src/bin/swap.rs
Unescape Escape View File

@ -505,6 +505,7 @@ async fn init_bitcoin_wallet(
let wallet = bitcoin::Wallet::new(
electrum_rpc_url.clone(),
"",
data_dir,
xprivkey,
env_config,

38
swap/src/bitcoin/wallet.rs
Unescape Escape View File

@ -6,7 +6,7 @@ use ::bitcoin::Txid;
use anyhow::{bail, Context, Result};
use bdk::blockchain::{Blockchain, ElectrumBlockchain, GetTx};
use bdk::database::BatchDatabase;
use bdk::electrum_client::{ElectrumApi, GetHistoryRes};
use bdk::electrum_client::{ElectrumApi, GetHistoryRes, Socks5Config};
use bdk::sled::Tree;
use bdk::wallet::export::FullyNodedExport;
use bdk::wallet::AddressIndex;
@ -20,6 +20,7 @@ use rust_decimal_macros::dec;
use std::collections::{BTreeMap, HashMap};
use std::convert::TryFrom;
use std::fmt;
use std::ops::Not;
use std::path::Path;
use std::sync::Arc;
use std::time::{Duration, Instant};
@ -47,6 +48,7 @@ pub struct Wallet<D = Tree, C = Client> {
impl Wallet {
pub async fn new(
electrum_rpc_url: Url,
electrum_socks5_proxy_string: &str,
data_dir: impl AsRef<Path>,
xprivkey: ExtendedPrivKey,
env_config: env::Config,
@ -70,7 +72,11 @@ impl Wallet {
err => err?,
};
let client = Client::new(electrum_rpc_url, env_config.bitcoin_sync_interval())?;
let client = Client::new(
electrum_rpc_url,
electrum_socks5_proxy_string,
env_config.bitcoin_sync_interval(),
)?;
let network = wallet.network();
@ -723,20 +729,32 @@ pub struct Client {
}
impl Client {
fn new(electrum_rpc_url: Url, interval: Duration) -> Result<Self> {
let config = bdk::electrum_client::ConfigBuilder::default()
.retry(5)
.build();
let electrum = bdk::electrum_client::Client::from_config(electrum_rpc_url.as_str(), config)
.context("Failed to initialize Electrum RPC client")?;
fn new(
electrum_rpc_url: Url,
electrum_socks5_proxy_string: &str,
interval: Duration,
) -> Result<Self> {
let mut config_builder = bdk::electrum_client::ConfigBuilder::default().retry(5);
if electrum_socks5_proxy_string.is_empty().not() {
config_builder = config_builder
.socks5(Option::from(Socks5Config::new(
electrum_socks5_proxy_string.to_string(),
)))
.unwrap() // use Tor with the Electrum client
}
let config = config_builder.build();
let electrum =
bdk::electrum_client::Client::from_config(electrum_rpc_url.as_str(), config.clone())
.context("Failed to initialize Electrum RPC client")?;
// Initially fetch the latest block for storing the height.
// We do not act on this subscription after this call.
let latest_block = electrum
.block_headers_subscribe()
.context("Failed to subscribe to header notifications")?;
let client = bdk::electrum_client::Client::new(electrum_rpc_url.as_str())
.context("Failed to initialize Electrum RPC client")?;
let client =
bdk::electrum_client::Client::from_config(electrum_rpc_url.as_str(), config.clone())
.context("Failed to initialize Electrum RPC client")?;
let blockchain = ElectrumBlockchain::from(client);
let last_sync = Instant::now()
.checked_sub(interval)

10
swap/src/network/swarm.rs
Unescape Escape View File

@ -9,7 +9,7 @@ use libp2p::{identity, Multiaddr, Swarm};
use std::fmt::Debug;
#[allow(clippy::too_many_arguments)]
pub fn asb<LR>(
pub async fn asb<LR>(
seed: &Seed,
min_buy: bitcoin::Amount,
max_buy: bitcoin::Amount,
@ -18,10 +18,16 @@ pub fn asb<LR>(
env_config: env::Config,
namespace: XmrBtcNamespace,
rendezvous_addrs: &[Multiaddr],
tor_socks5_port: u16,
) -> Result<Swarm<asb::Behaviour<LR>>>
where
LR: LatestRate + Send + 'static + Debug + Clone,
{
let maybe_tor_socks5_port = match tor::Client::new(tor_socks5_port).assert_tor_running().await {
Ok(()) => Some(tor_socks5_port),
Err(_) => None,
};
let identity = seed.derive_libp2p_identity();
let rendezvous_nodes = rendezvous_addrs
@ -45,7 +51,7 @@ where
rendezvous_nodes,
);
let transport = asb::transport::new(&identity)?;
let transport = asb::transport::new(&identity, maybe_tor_socks5_port)?;
let peer_id = identity.public().into();
let swarm = SwarmBuilder::new(transport, behaviour, peer_id)

Write Preview
Loading…
Cancel
Save