diff --git a/swap/src/api.rs b/swap/src/api.rs
index 5e343115..0f5805cd 100644
--- a/swap/src/api.rs
+++ b/swap/src/api.rs
@@ -295,7 +295,6 @@ pub mod api_test {
 
     use libp2p::Multiaddr;
     use std::str::FromStr;
-    use tokio::sync::broadcast;
     use uuid::Uuid;
 
     pub const MULTI_ADDRESS: &str =
@@ -333,7 +332,7 @@ pub mod api_test {
     }
 
     impl Request {
-        pub fn buy_xmr(is_testnet: bool, tx: broadcast::Sender<()>) -> Request {
+        pub fn buy_xmr(is_testnet: bool) -> Request {
             let seller = Multiaddr::from_str(MULTI_ADDRESS).unwrap();
             let bitcoin_change_address = {
                 if is_testnet {
@@ -352,43 +351,35 @@ pub mod api_test {
             };
 
             Request::new(
-                Method::BuyXmr,
-                Params {
-                    seller: Some(seller),
-                    bitcoin_change_address: Some(bitcoin_change_address),
-                    monero_receive_address: Some(monero_receive_address),
-                    swap_id: Some(Uuid::new_v4()),
-                    ..Default::default()
+                Method::BuyXmr { 
+                    seller,
+                    bitcoin_change_address,
+                    monero_receive_address,
+                    swap_id: Uuid::new_v4(),
                 },
             )
         }
 
         pub fn resume() -> Request {
             Request::new(
-                Method::Resume,
-                Params {
-                    swap_id: Some(Uuid::from_str(SWAP_ID).unwrap()),
-                    ..Default::default()
+                Method::Resume {
+                    swap_id: Uuid::from_str(SWAP_ID).unwrap(),
                 },
             )
         }
 
         pub fn cancel() -> Request {
             Request::new(
-                Method::CancelAndRefund,
-                Params {
-                    swap_id: Some(Uuid::from_str(SWAP_ID).unwrap()),
-                    ..Default::default()
+                Method::CancelAndRefund {
+                    swap_id: Uuid::from_str(SWAP_ID).unwrap(),
                 },
             )
         }
 
         pub fn refund() -> Request {
             Request::new(
-                Method::CancelAndRefund,
-                Params {
-                    swap_id: Some(Uuid::from_str(SWAP_ID).unwrap()),
-                    ..Default::default()
+                Method::CancelAndRefund {
+                    swap_id: Uuid::from_str(SWAP_ID).unwrap(),
                 },
             )
         }
diff --git a/swap/src/api/request.rs b/swap/src/api/request.rs
index 36fbcd0b..be4b03fe 100644
--- a/swap/src/api/request.rs
+++ b/swap/src/api/request.rs
@@ -21,6 +21,7 @@ use std::time::Duration;
 use tracing::{debug_span, field, Instrument, Span};
 use uuid::Uuid;
 
+//TODO: Request and Method can be combined into a single enum
 #[derive(PartialEq, Debug)]
 pub struct Request {
     pub cmd: Method,
@@ -272,6 +273,7 @@ impl Request {
                     | BobState::XmrRedeemed { .. } => None,
                 };
 
+                // TODO: Add relevant txids
                 Ok(json!({
                     "swapId": swap_id,
                     "seller": {
diff --git a/swap/src/bitcoin.rs b/swap/src/bitcoin.rs
index 683f1dd5..2ac0aa78 100644
--- a/swap/src/bitcoin.rs
+++ b/swap/src/bitcoin.rs
@@ -371,6 +371,7 @@ mod tests {
     use crate::protocol::{alice, bob};
     use rand::rngs::OsRng;
     use uuid::Uuid;
+    use std::matches;
 
     #[test]
     fn lock_confirmations_le_to_cancel_timelock_no_timelock_expired() {
@@ -384,7 +385,7 @@ mod tests {
             tx_cancel_status,
         );
 
-        assert_eq!(expired_timelock, ExpiredTimelocks::None)
+        assert!(matches!(expired_timelock, ExpiredTimelocks::None { .. }));
     }
 
     #[test]
@@ -399,7 +400,7 @@ mod tests {
             tx_cancel_status,
         );
 
-        assert_eq!(expired_timelock, ExpiredTimelocks::Cancel)
+        assert!(matches!(expired_timelock, ExpiredTimelocks::Cancel {..}));
     }
 
     #[test]
diff --git a/swap/src/bitcoin/wallet.rs b/swap/src/bitcoin/wallet.rs
index fac02cd5..b133bb8c 100644
--- a/swap/src/bitcoin/wallet.rs
+++ b/swap/src/bitcoin/wallet.rs
@@ -1006,9 +1006,10 @@ mod tests {
 
     #[test]
     fn given_depth_0_should_meet_confirmation_target_one() {
+
         let script = ScriptStatus::Confirmed(Confirmed { depth: 0 });
 
-        let confirmed = script.is_confirmed_with(1);
+        let confirmed = script.is_confirmed_with(1 as u32);
 
         assert!(confirmed)
     }
@@ -1017,7 +1018,7 @@ mod tests {
     fn given_confirmations_1_should_meet_confirmation_target_one() {
         let script = ScriptStatus::from_confirmations(1);
 
-        let confirmed = script.is_confirmed_with(1);
+        let confirmed = script.is_confirmed_with(1 as u32);
 
         assert!(confirmed)
     }
@@ -1036,7 +1037,7 @@ mod tests {
     fn given_depth_0_should_return_0_blocks_left_until_1() {
         let script = ScriptStatus::Confirmed(Confirmed { depth: 0 });
 
-        let blocks_left = script.blocks_left_until(1);
+        let blocks_left = script.blocks_left_until(1 as u32);
 
         assert_eq!(blocks_left, 0)
     }
@@ -1045,7 +1046,7 @@ mod tests {
     fn given_depth_1_should_return_0_blocks_left_until_1() {
         let script = ScriptStatus::Confirmed(Confirmed { depth: 1 });
 
-        let blocks_left = script.blocks_left_until(1);
+        let blocks_left = script.blocks_left_until(1 as u32);
 
         assert_eq!(blocks_left, 0)
     }
@@ -1054,7 +1055,7 @@ mod tests {
     fn given_depth_0_should_return_1_blocks_left_until_2() {
         let script = ScriptStatus::Confirmed(Confirmed { depth: 0 });
 
-        let blocks_left = script.blocks_left_until(2);
+        let blocks_left = script.blocks_left_until(2 as u32);
 
         assert_eq!(blocks_left, 1)
     }
diff --git a/swap/src/cli/command.rs b/swap/src/cli/command.rs
index 6f21e98a..86e48f16 100644
--- a/swap/src/cli/command.rs
+++ b/swap/src/cli/command.rs
@@ -501,13 +501,13 @@ mod tests {
     use crate::api::Config;
     use crate::fs::system_data_dir;
     use crate::monero::monero_address::MoneroAddressNetworkMismatch;
-    use sequential_test::sequential;
+    use serial_test::serial;
 
     const BINARY_NAME: &str = "swap";
     const ARGS_DATA_DIR: &str = "/tmp/dir/";
 
     #[tokio::test]
-    #[sequential]
+    #[serial]
     async fn given_buy_xmr_on_mainnet_then_defaults_to_mainnet() {
         let raw_ars = vec![
             BINARY_NAME,
@@ -538,7 +538,7 @@ mod tests {
     }
 
     #[tokio::test]
-    #[sequential]
+    #[serial]
     async fn given_buy_xmr_on_testnet_then_defaults_to_testnet() {
         let raw_ars = vec![
             BINARY_NAME,
@@ -570,7 +570,7 @@ mod tests {
     }
 
     #[tokio::test]
-    #[sequential]
+    #[serial]
     async fn given_buy_xmr_on_mainnet_with_testnet_address_then_fails() {
         let raw_ars = vec![
             BINARY_NAME,
@@ -595,7 +595,7 @@ mod tests {
     }
 
     #[tokio::test]
-    #[sequential]
+    #[serial]
     async fn given_buy_xmr_on_testnet_with_mainnet_address_then_fails() {
         let raw_ars = vec![
             BINARY_NAME,
@@ -621,7 +621,7 @@ mod tests {
     }
 
     #[tokio::test]
-    #[sequential]
+    #[serial]
     async fn given_resume_on_mainnet_then_defaults_to_mainnet() {
         let raw_ars = vec![BINARY_NAME, "resume", "--swap-id", SWAP_ID];
 
@@ -643,11 +643,10 @@ mod tests {
     }
 
     #[tokio::test]
-    #[sequential]
+    #[serial]
     async fn given_resume_on_testnet_then_defaults_to_testnet() {
         let raw_ars = vec![BINARY_NAME, "--testnet", "resume", "--swap-id", SWAP_ID];
 
-        let (tx, _) = broadcast::channel(1);
         let args = parse_args_and_apply_defaults(raw_ars).await.unwrap();
         let (is_testnet, debug, json) = (true, false, false);
 
@@ -666,11 +665,10 @@ mod tests {
     }
 
     #[tokio::test]
-    #[sequential]
+    #[serial]
     async fn given_cancel_on_mainnet_then_defaults_to_mainnet() {
         let raw_ars = vec![BINARY_NAME, "cancel", "--swap-id", SWAP_ID];
 
-        let (tx, _) = broadcast::channel(1);
         let args = parse_args_and_apply_defaults(raw_ars).await.unwrap();
 
         let (is_testnet, debug, json) = (false, false, false);
@@ -690,11 +688,10 @@ mod tests {
     }
 
     #[tokio::test]
-    #[sequential]
+    #[serial]
     async fn given_cancel_on_testnet_then_defaults_to_testnet() {
         let raw_ars = vec![BINARY_NAME, "--testnet", "cancel", "--swap-id", SWAP_ID];
 
-        let (tx, _) = broadcast::channel(1);
         let args = parse_args_and_apply_defaults(raw_ars).await.unwrap();
         let (is_testnet, debug, json) = (true, false, false);
 
@@ -713,11 +710,10 @@ mod tests {
     }
 
     #[tokio::test]
-    #[sequential]
+    #[serial]
     async fn given_refund_on_mainnet_then_defaults_to_mainnet() {
         let raw_ars = vec![BINARY_NAME, "refund", "--swap-id", SWAP_ID];
 
-        let (tx, _) = broadcast::channel(1);
         let args = parse_args_and_apply_defaults(raw_ars).await.unwrap();
         let (is_testnet, debug, json) = (false, false, false);
 
@@ -736,11 +732,10 @@ mod tests {
     }
 
     #[tokio::test]
-    #[sequential]
+    #[serial]
     async fn given_refund_on_testnet_then_defaults_to_testnet() {
         let raw_ars = vec![BINARY_NAME, "--testnet", "refund", "--swap-id", SWAP_ID];
 
-        let (tx, _) = broadcast::channel(1);
         let args = parse_args_and_apply_defaults(raw_ars).await.unwrap();
         let (is_testnet, debug, json) = (true, false, false);
 
@@ -759,7 +754,7 @@ mod tests {
     }
 
     #[tokio::test]
-    #[sequential]
+    #[serial]
     async fn given_buy_xmr_on_mainnet_with_data_dir_then_data_dir_set() {
         let raw_ars = vec![
             BINARY_NAME,
@@ -774,7 +769,6 @@ mod tests {
             MULTI_ADDRESS,
         ];
 
-        let (tx, _) = broadcast::channel(1);
         let args = parse_args_and_apply_defaults(raw_ars).await.unwrap();
         let (is_testnet, debug, json) = (false, false, false);
         let data_dir = PathBuf::from_str(ARGS_DATA_DIR).unwrap();
@@ -794,7 +788,7 @@ mod tests {
     }
 
     #[tokio::test]
-    #[sequential]
+    #[serial]
     async fn given_buy_xmr_on_testnet_with_data_dir_then_data_dir_set() {
         let raw_ars = vec![
             BINARY_NAME,
@@ -810,7 +804,6 @@ mod tests {
             MULTI_ADDRESS,
         ];
 
-        let (tx, _) = broadcast::channel(1);
         let data_dir = PathBuf::from_str(ARGS_DATA_DIR).unwrap();
         let args = parse_args_and_apply_defaults(raw_ars).await.unwrap();
         let (is_testnet, debug, json) = (true, false, false);
@@ -830,7 +823,7 @@ mod tests {
     }
 
     #[tokio::test]
-    #[sequential]
+    #[serial]
     async fn given_resume_on_mainnet_with_data_dir_then_data_dir_set() {
         let raw_ars = vec![
             BINARY_NAME,
@@ -841,7 +834,6 @@ mod tests {
             SWAP_ID,
         ];
 
-        let (tx, _) = broadcast::channel(1);
         let data_dir = PathBuf::from_str(ARGS_DATA_DIR).unwrap();
         let args = parse_args_and_apply_defaults(raw_ars).await.unwrap();
         let (is_testnet, debug, json) = (false, false, false);
@@ -861,7 +853,7 @@ mod tests {
     }
 
     #[tokio::test]
-    #[sequential]
+    #[serial]
     async fn given_resume_on_testnet_with_data_dir_then_data_dir_set() {
         let raw_ars = vec![
             BINARY_NAME,
@@ -873,7 +865,6 @@ mod tests {
             SWAP_ID,
         ];
 
-        let (tx, _) = broadcast::channel(1);
         let data_dir = PathBuf::from_str(ARGS_DATA_DIR).unwrap();
         let args = parse_args_and_apply_defaults(raw_ars).await.unwrap();
         let (is_testnet, debug, json) = (true, false, false);
@@ -893,7 +884,7 @@ mod tests {
     }
 
     #[tokio::test]
-    #[sequential]
+    #[serial]
     async fn given_buy_xmr_on_mainnet_with_debug_then_debug_set() {
         let raw_ars = vec![
             BINARY_NAME,
@@ -907,7 +898,6 @@ mod tests {
             MULTI_ADDRESS,
         ];
 
-        let (tx, _) = broadcast::channel(1);
         let args = parse_args_and_apply_defaults(raw_ars).await.unwrap();
         let (is_testnet, debug, json) = (false, true, false);
 
@@ -926,7 +916,7 @@ mod tests {
     }
 
     #[tokio::test]
-    #[sequential]
+    #[serial]
     async fn given_buy_xmr_on_testnet_with_debug_then_debug_set() {
         let raw_ars = vec![
             BINARY_NAME,
@@ -941,7 +931,6 @@ mod tests {
             MULTI_ADDRESS,
         ];
 
-        let (tx, _) = broadcast::channel(1);
         let args = parse_args_and_apply_defaults(raw_ars).await.unwrap();
         let (is_testnet, debug, json) = (true, true, false);
 
@@ -960,11 +949,10 @@ mod tests {
     }
 
     #[tokio::test]
-    #[sequential]
+    #[serial]
     async fn given_resume_on_mainnet_with_debug_then_debug_set() {
         let raw_ars = vec![BINARY_NAME, "--debug", "resume", "--swap-id", SWAP_ID];
 
-        let (tx, _) = broadcast::channel(1);
         let args = parse_args_and_apply_defaults(raw_ars).await.unwrap();
         let (is_testnet, debug, json) = (false, true, false);
 
@@ -983,7 +971,7 @@ mod tests {
     }
 
     #[tokio::test]
-    #[sequential]
+    #[serial]
     async fn given_resume_on_testnet_with_debug_then_debug_set() {
         let raw_ars = vec![
             BINARY_NAME,
@@ -994,7 +982,6 @@ mod tests {
             SWAP_ID,
         ];
 
-        let (tx, _) = broadcast::channel(1);
         let args = parse_args_and_apply_defaults(raw_ars).await.unwrap();
         let (is_testnet, debug, json) = (true, true, false);
 
@@ -1013,7 +1000,7 @@ mod tests {
     }
 
     #[tokio::test]
-    #[sequential]
+    #[serial]
     async fn given_buy_xmr_on_mainnet_with_json_then_json_set() {
         let raw_ars = vec![
             BINARY_NAME,
@@ -1027,7 +1014,6 @@ mod tests {
             MULTI_ADDRESS,
         ];
 
-        let (tx, _) = broadcast::channel(1);
         let args = parse_args_and_apply_defaults(raw_ars).await.unwrap();
         let (is_testnet, debug, json) = (false, false, true);
         let data_dir = data_dir_path_cli(is_testnet);
@@ -1047,7 +1033,7 @@ mod tests {
     }
 
     #[tokio::test]
-    #[sequential]
+    #[serial]
     async fn given_buy_xmr_on_testnet_with_json_then_json_set() {
         let raw_ars = vec![
             BINARY_NAME,
@@ -1062,14 +1048,13 @@ mod tests {
             MULTI_ADDRESS,
         ];
 
-        let (tx, _) = broadcast::channel(1);
-        let args = parse_args_and_apply_defaults(raw_ars).await.unwrap();
         let (is_testnet, debug, json) = (true, false, true);
 
         let (expected_config, expected_request) = (
             Config::default(is_testnet, None, debug, json),
             Request::buy_xmr(is_testnet),
         );
+        let args = parse_args_and_apply_defaults(raw_ars).await.unwrap();
 
         let (actual_config, actual_request) = match args {
             ParseResult::Context(context, request) => (context.config.clone(), request),
@@ -1081,9 +1066,8 @@ mod tests {
     }
 
     #[tokio::test]
-    #[sequential]
+    #[serial]
     async fn given_resume_on_mainnet_with_json_then_json_set() {
-        let (tx, _) = broadcast::channel(1);
         let raw_ars = vec![BINARY_NAME, "--json", "resume", "--swap-id", SWAP_ID];
         let args = parse_args_and_apply_defaults(raw_ars).await.unwrap();
         let (is_testnet, debug, json) = (false, false, true);
@@ -1103,7 +1087,7 @@ mod tests {
     }
 
     #[tokio::test]
-    #[sequential]
+    #[serial]
     async fn given_resume_on_testnet_with_json_then_json_set() {
         let raw_ars = vec![
             BINARY_NAME,
@@ -1114,7 +1098,6 @@ mod tests {
             SWAP_ID,
         ];
 
-        let (tx, _) = broadcast::channel(1);
         let args = parse_args_and_apply_defaults(raw_ars).await.unwrap();
         let (is_testnet, debug, json) = (true, false, true);
 
@@ -1133,7 +1116,7 @@ mod tests {
     }
 
     #[tokio::test]
-    #[sequential]
+    #[serial]
     async fn only_bech32_addresses_mainnet_are_allowed() {
         let raw_ars = vec![
             BINARY_NAME,
@@ -1145,7 +1128,6 @@ mod tests {
             "--seller",
             MULTI_ADDRESS,
         ];
-        let (tx, _) = broadcast::channel(1);
         let result = parse_args_and_apply_defaults(raw_ars).await.unwrap_err();
 
         let raw_ars = vec![
@@ -1175,9 +1157,8 @@ mod tests {
     }
 
     #[tokio::test]
-    #[sequential]
+    #[serial]
     async fn only_bech32_addresses_testnet_are_allowed() {
-        let (tx, _) = broadcast::channel(1);
         let raw_ars = vec![
             BINARY_NAME,
             "--testnet",
diff --git a/swap/src/rpc/methods.rs b/swap/src/rpc/methods.rs
index c5fa461c..b7dc39cc 100644
--- a/swap/src/rpc/methods.rs
+++ b/swap/src/rpc/methods.rs
@@ -51,7 +51,7 @@ pub fn register_modules(context: Arc<Context>) -> RpcModule<Arc<Context>> {
         .unwrap();
 
     module
-        .register_async_method("get_raw_states", |params, context| async move {
+        .register_async_method("get_raw_history", |params, context| async move {
             execute_request(params, Method::GetRawStates, &context).await
         })
         .unwrap();
diff --git a/swap/tests/rpc.rs b/swap/tests/rpc.rs
index 6f516624..f034e7b1 100644
--- a/swap/tests/rpc.rs
+++ b/swap/tests/rpc.rs
@@ -5,17 +5,15 @@ use jsonrpsee::ws_client::WsClientBuilder;
 use jsonrpsee_core::client::ClientT;
 use jsonrpsee_core::params::ObjectParams;
 
-use sequential_test::sequential;
+use serial_test::serial;
 
 use std::collections::HashMap;
 use std::sync::Arc;
 use std::time::Duration;
-use swap::api::request::{Method, Params, Request, Shutdown};
+use swap::api::request::{Method, Request };
 use swap::api::Context;
 use swap::cli::command::{Bitcoin, Monero};
 
-use tokio::sync::broadcast;
-
 use uuid::Uuid;
 
 #[cfg(test)]
@@ -34,7 +32,6 @@ pub async fn initialize_context() -> (Arc<Context>, Request) {
     let (is_testnet, debug, json) = (true, false, false);
     // let data_dir = data::data_dir_from(None, is_testnet).unwrap();
     let server_address = None;
-    let (tx, _) = broadcast::channel(1);
 
     let bitcoin = Bitcoin {
         bitcoin_electrum_rpc_url: None,
@@ -45,7 +42,7 @@ pub async fn initialize_context() -> (Arc<Context>, Request) {
         monero_daemon_address: None,
     };
 
-    let request = Request::new(tx.subscribe(), Method::StartDaemon, Params::default());
+    let request = Request::new(Method::StartDaemon { server_address: None });
 
     let context = Context::build(
         Some(bitcoin),
@@ -56,7 +53,6 @@ pub async fn initialize_context() -> (Arc<Context>, Request) {
         debug,
         json,
         server_address,
-        tx,
     )
     .await
     .unwrap();
@@ -65,7 +61,7 @@ pub async fn initialize_context() -> (Arc<Context>, Request) {
 }
 
 #[tokio::test]
-#[sequential]
+#[serial]
 pub async fn can_start_server() {
     let (ctx, mut request) = initialize_context().await;
     let move_ctx = Arc::clone(&ctx);
@@ -73,12 +69,11 @@ pub async fn can_start_server() {
         request.call(Arc::clone(&move_ctx)).await;
     });
     tokio::time::sleep(Duration::from_secs(3)).await;
-    ctx.shutdown.send(());
     assert!(true);
 }
 
 #[tokio::test]
-#[sequential]
+#[serial]
 pub async fn get_bitcoin_balance() {
     let (ctx, mut request) = initialize_context().await;
     let move_ctx = Arc::clone(&ctx);
@@ -96,11 +91,10 @@ pub async fn get_bitcoin_balance() {
         .unwrap();
 
     assert_eq!(response, HashMap::from([("balance".to_string(), 0)]));
-    ctx.shutdown.send(());
 }
 
 #[tokio::test]
-#[sequential]
+#[serial]
 pub async fn get_history() {
     let (ctx, mut request) = initialize_context().await;
     let move_ctx = Arc::clone(&ctx);
@@ -119,11 +113,10 @@ pub async fn get_history() {
     let swaps: Vec<(Uuid, String)> = Vec::new();
 
     assert_eq!(response, HashMap::from([("swaps".to_string(), swaps)]));
-    ctx.shutdown.send(());
 }
 
 #[tokio::test]
-#[sequential]
+#[serial]
 pub async fn get_raw_history() {
     let (ctx, mut request) = initialize_context().await;
     let move_ctx = Arc::clone(&ctx);
@@ -145,11 +138,10 @@ pub async fn get_raw_history() {
         response,
         HashMap::from([("raw_history".to_string(), raw_history)])
     );
-    ctx.shutdown.send(());
 }
 
 #[tokio::test]
-#[sequential]
+#[serial]
 pub async fn get_seller() {
     let (ctx, mut request) = initialize_context().await;
     let move_ctx = Arc::clone(&ctx);
@@ -197,11 +189,10 @@ pub async fn get_seller() {
             e
         ),
     }
-    ctx.shutdown.send(());
 }
 
 #[tokio::test]
-#[sequential]
+#[serial]
 pub async fn get_swap_start_date() {
     let (ctx, mut request) = initialize_context().await;
     let move_ctx = Arc::clone(&ctx);
@@ -244,11 +235,10 @@ pub async fn get_swap_start_date() {
         Ok(hash) => (),
         Err(e) => panic!("Expected a HashMap, got an error: {}", e),
     }
-    ctx.shutdown.send(());
 }
 
 #[tokio::test]
-#[sequential]
+#[serial]
 pub async fn resume_swap() {
     let (ctx, mut request) = initialize_context().await;
     let move_ctx = Arc::clone(&ctx);
@@ -291,11 +281,10 @@ pub async fn resume_swap() {
         Ok(hash) => (),
         Err(e) => panic!("Expected a HashMap, got an error: {}", e),
     }
-    ctx.shutdown.send(());
 }
 
 #[tokio::test]
-#[sequential]
+#[serial]
 pub async fn withdraw_btc() {
     let (ctx, mut request) = initialize_context().await;
     let move_ctx = Arc::clone(&ctx);
@@ -348,11 +337,10 @@ pub async fn withdraw_btc() {
         Err(e) => panic!("Expected a HashMap, got an error: {}", e),
     }
 
-    ctx.shutdown.send(());
 }
 
 #[tokio::test]
-#[sequential]
+#[serial]
 pub async fn buy_xmr() {
     let (ctx, mut request) = initialize_context().await;
     let move_ctx = Arc::clone(&ctx);
@@ -454,5 +442,4 @@ pub async fn buy_xmr() {
         Err(e) => panic!("Expected a HashMap, got an error: {}", e),
     }
 
-    ctx.shutdown.send(());
 }