wip: remove Request struct, imports failing

swap/src/api/request.rs

@@ -290,7 +290,10 @@ pub async fn get_swap_info(
 }
 
 #[tracing::instrument(fields(method = "buy_xmr"), skip(context))]
-pub async fn buy_xmr(buy_xmr: BuyXmrArgs, context: Arc<Context>) -> Result<serde_json::Value> {
+pub async fn buy_xmr(
+    buy_xmr: BuyXmrArgs,
+    context: Arc<Context>,
+) -> Result<serde_json::Value, anyhow::Error> {
     let BuyXmrArgs {
         seller,
         bitcoin_change_address,

swap/src/bin/swap.rs

@@ -21,19 +21,18 @@ use std::env;
 
 #[tokio::main]
 pub async fn main() -> Result<()> {
-    let (context, request) = match parse_args_and_apply_defaults(env::args_os()).await? {
+    if let Err(e) = check_latest_version(env!("CARGO_PKG_VERSION")).await {
-        ParseResult::Context(context, request) => (context, request),
+        eprintln!("{}", e);
+    }
+
+    match parse_args_and_apply_defaults(env::args_os()).await? {
+        ParseResult::Success => {}
         ParseResult::PrintAndExitZero { message } => {
             println!("{}", message);
             std::process::exit(0);
         }
     };
 
-    if let Err(e) = check_latest_version(env!("CARGO_PKG_VERSION")).await {
-        eprintln!("{}", e);
-    }
-    request.call(context.clone()).await?;
-    context.tasks.wait_for_tasks().await?;
     Ok(())
 }
 

swap/src/cli/command.rs

@@ -1,6 +1,8 @@
 use crate::api::request::{
-    BalanceArgs, BuyXmrArgs, CancelAndRefundArgs, ListSellersArgs, Method, MoneroRecoveryArgs,
+    buy_xmr, cancel_and_refund, export_bitcoin_wallet, get_balance, get_config, get_history,
-    Request, ResumeArgs, StartDaemonArgs, WithdrawBtcArgs,
+    list_sellers, monero_recovery, resume_swap, start_daemon, withdraw_btc, BalanceArgs,
+    BuyXmrArgs, CancelAndRefundArgs, ListSellersArgs, Method, MoneroRecoveryArgs, Request,
+    ResumeArgs, StartDaemonArgs, WithdrawBtcArgs,
 };
 use crate::api::Context;
 use crate::bitcoin::{bitcoin_address, Amount};
@@ -8,6 +10,7 @@ use crate::monero;
 use crate::monero::monero_address;
 use anyhow::Result;
 use libp2p::core::Multiaddr;
+use serde_json::Value;
 use std::ffi::OsString;
 use std::net::SocketAddr;
 use std::path::PathBuf;
@@ -36,7 +39,7 @@ const DEFAULT_TOR_SOCKS5_PORT: &str = "9050";
 #[derive(Debug)]
 pub enum ParseResult {
     /// The arguments we were invoked in.
-    Context(Arc<Context>, Box<Request>),
+    Success,
     /// A flag or command was given that does not need further processing other
     /// than printing the provided message.
     ///
@@ -63,7 +66,7 @@ where
     let json = args.json;
     let is_testnet = args.testnet;
     let data = args.data;
-    let (context, request) = match args.cmd {
+    let result = match args.cmd {
         CliCommand::BuyXmr {
             seller: Seller { seller },
             bitcoin,
@@ -77,14 +80,8 @@ where
             let bitcoin_change_address =
                 bitcoin_address::validate_is_testnet(bitcoin_change_address, is_testnet)?;
 
-            let request = Request::new(Method::BuyXmr(BuyXmrArgs {
+            let context = Arc::new(
-                seller,
+                Context::build(
-                bitcoin_change_address,
-                monero_receive_address,
-                swap_id: Uuid::new_v4(),
-            }));
-
-            let context = Context::build(
                     Some(bitcoin),
                     Some(monero),
                     Some(tor),
@@ -94,29 +91,43 @@ where
                     json,
                     None,
                 )
+                .await?,
+            );
+
+            buy_xmr(
+                BuyXmrArgs {
+                    seller,
+                    bitcoin_change_address,
+                    monero_receive_address,
+                    swap_id: Uuid::new_v4(),
+                },
+                context,
+            )
             .await?;
-            (context, request)
+
+            Ok(()) as Result<(), anyhow::Error>
         }
         CliCommand::History => {
-            let request = Request::new(Method::History);
+            let context = Arc::new(
+                Context::build(None, None, None, data, is_testnet, debug, json, None).await?,
+            );
 
-            let context =
+            get_history(context).await?;
-                Context::build(None, None, None, data, is_testnet, debug, json, None).await?;
+
-            (context, request)
+            Ok(())
         }
         CliCommand::Config => {
-            let request = Request::new(Method::Config);
+            let context = Arc::new(
+                Context::build(None, None, None, data, is_testnet, debug, json, None).await?,
+            );
 
-            let context =
+            get_config(context).await?;
-                Context::build(None, None, None, data, is_testnet, debug, json, None).await?;
+
-            (context, request)
+            Ok(())
         }
         CliCommand::Balance { bitcoin } => {
-            let request = Request::new(Method::Balance(BalanceArgs {
+            let context = Arc::new(
-                force_refresh: true,
+                Context::build(
-            }));
-
-            let context = Context::build(
                     Some(bitcoin),
                     None,
                     None,
@@ -126,8 +137,18 @@ where
                     json,
                     None,
                 )
+                .await?,
+            );
+
+            get_balance(
+                BalanceArgs {
+                    force_refresh: true,
+                },
+                context,
+            )
             .await?;
-            (context, request)
+
+            Ok(())
         }
         CliCommand::StartDaemon {
             server_address,
@@ -135,9 +156,8 @@ where
             monero,
             tor,
         } => {
-            let request = Request::new(Method::StartDaemon(StartDaemonArgs { server_address }));
+            let context = Arc::new(
-
+                Context::build(
-            let context = Context::build(
                     Some(bitcoin),
                     Some(monero),
                     Some(tor),
@@ -147,8 +167,12 @@ where
                     json,
                     server_address,
                 )
-            .await?;
+                .await?,
-            (context, request)
+            );
+
+            start_daemon(StartDaemonArgs { server_address }, context).await?;
+
+            Ok(())
         }
         CliCommand::WithdrawBtc {
             bitcoin,
@@ -156,9 +180,9 @@ where
             address,
         } => {
             let address = bitcoin_address::validate_is_testnet(address, is_testnet)?;
-            let request = Request::new(Method::WithdrawBtc(WithdrawBtcArgs { amount, address }));
 
-            let context = Context::build(
+            let context = Arc::new(
+                Context::build(
                     Some(bitcoin),
                     None,
                     None,
@@ -168,8 +192,12 @@ where
                     json,
                     None,
                 )
-            .await?;
+                .await?,
-            (context, request)
+            );
+
+            withdraw_btc(WithdrawBtcArgs { amount, address }, context).await?;
+
+            Ok(())
         }
         CliCommand::Resume {
             swap_id: SwapId { swap_id },
@@ -177,9 +205,8 @@ where
             monero,
             tor,
         } => {
-            let request = Request::new(Method::Resume(ResumeArgs { swap_id }));
+            let context = Arc::new(
-
+                Context::build(
-            let context = Context::build(
                     Some(bitcoin),
                     Some(monero),
                     Some(tor),
@@ -189,17 +216,20 @@ where
                     json,
                     None,
                 )
-            .await?;
+                .await?,
-            (context, request)
+            );
+
+            resume_swap(ResumeArgs { swap_id }, context).await?;
+
+            Ok(())
         }
         CliCommand::CancelAndRefund {
             swap_id: SwapId { swap_id },
             bitcoin,
             tor,
         } => {
-            let request = Request::new(Method::CancelAndRefund(CancelAndRefundArgs { swap_id }));
+            let context = Arc::new(
-
+                Context::build(
-            let context = Context::build(
                     Some(bitcoin),
                     None,
                     Some(tor),
@@ -209,24 +239,28 @@ where
                     json,
                     None,
                 )
-            .await?;
+                .await?,
-            (context, request)
+            );
+
+            cancel_and_refund(CancelAndRefundArgs { swap_id }, context).await?;
+
+            Ok(())
         }
         CliCommand::ListSellers {
             rendezvous_point,
             tor,
         } => {
-            let request = Request::new(Method::ListSellers(ListSellersArgs { rendezvous_point }));
+            let context = Arc::new(
+                Context::build(None, None, Some(tor), data, is_testnet, debug, json, None).await?,
+            );
 
-            let context =
+            list_sellers(ListSellersArgs { rendezvous_point }, context).await?;
-                Context::build(None, None, Some(tor), data, is_testnet, debug, json, None).await?;
 
-            (context, request)
+            Ok(())
         }
         CliCommand::ExportBitcoinWallet { bitcoin } => {
-            let request = Request::new(Method::ExportBitcoinWallet);
+            let context = Arc::new(
-
+                Context::build(
-            let context = Context::build(
                     Some(bitcoin),
                     None,
                     None,
@@ -236,22 +270,29 @@ where
                     json,
                     None,
                 )
-            .await?;
+                .await?,
-            (context, request)
+            );
+
+            export_bitcoin_wallet(context).await?;
+
+            Ok(())
         }
         CliCommand::MoneroRecovery {
             swap_id: SwapId { swap_id },
         } => {
-            let request = Request::new(Method::MoneroRecovery(MoneroRecoveryArgs { swap_id }));
+            let context = Arc::new(
+                Context::build(None, None, None, data, is_testnet, debug, json, None).await?,
+            );
 
-            let context =
+            monero_recovery(MoneroRecoveryArgs { swap_id }, context).await?;
-                Context::build(None, None, None, data, is_testnet, debug, json, None).await?;
 
-            (context, request)
+            Ok(())
         }
     };
 
-    Ok(ParseResult::Context(Arc::new(context), Box::new(request)))
+    result?;
+
+    Ok(ParseResult::Success)
 }
 
 #[derive(structopt::StructOpt, Debug)]