diff --git a/swap/src/api.rs b/swap/src/api.rs
index 06fdca91..92eddc77 100644
--- a/swap/src/api.rs
+++ b/swap/src/api.rs
@@ -159,11 +159,12 @@ impl Default for SwapLock {
 
 // workaround for warning over monero_rpc_process which we must own but not read
 #[allow(dead_code)]
+#[derive(Clone)]
 pub struct Context {
     pub db: Arc<dyn Database + Send + Sync>,
     bitcoin_wallet: Option<Arc<bitcoin::Wallet>>,
     monero_wallet: Option<Arc<monero::Wallet>>,
-    monero_rpc_process: Option<monero::WalletRpcProcess>,
+    monero_rpc_process: Option<Arc<monero::WalletRpcProcess>>,
     pub swap_lock: Arc<SwapLock>,
     pub config: Config,
     pub tasks: Arc<PendingTaskList>,
@@ -227,7 +228,7 @@ impl Context {
             db: open_db(data_dir.join("sqlite")).await?,
             bitcoin_wallet,
             monero_wallet,
-            monero_rpc_process,
+            monero_rpc_process: monero_rpc_process.map(Arc::new),
             config: Config {
                 tor_socks5_port,
                 namespace: XmrBtcNamespace::from_is_testnet(is_testnet),
diff --git a/swap/src/api/request.rs b/swap/src/api/request.rs
index f9a01071..12b0ad5a 100644
--- a/swap/src/api/request.rs
+++ b/swap/src/api/request.rs
@@ -679,7 +679,7 @@ pub async fn withdraw_btc(
 #[tracing::instrument(fields(method = "start_daemon"), skip(context))]
 pub async fn start_daemon(
     start_daemon: StartDaemonArgs,
-    context: Arc<Context>,
+    context: Context,
 ) -> Result<serde_json::Value> {
     let StartDaemonArgs { server_address } = start_daemon;
     // Default to 127.0.0.1:1234
diff --git a/swap/src/cli/command.rs b/swap/src/cli/command.rs
index e3cbc65b..6f7e8614 100644
--- a/swap/src/cli/command.rs
+++ b/swap/src/cli/command.rs
@@ -156,19 +156,17 @@ where
             monero,
             tor,
         } => {
-            let context = Arc::new(
-                Context::build(
-                    Some(bitcoin),
-                    Some(monero),
-                    Some(tor),
-                    data,
-                    is_testnet,
-                    debug,
-                    json,
-                    server_address,
-                )
-                .await?,
-            );
+            let context = Context::build(
+                Some(bitcoin),
+                Some(monero),
+                Some(tor),
+                data,
+                is_testnet,
+                debug,
+                json,
+                server_address,
+            )
+            .await?;
 
             start_daemon(StartDaemonArgs { server_address }, context).await?;
 
diff --git a/swap/src/rpc.rs b/swap/src/rpc.rs
index 3629b37b..dccd49d5 100644
--- a/swap/src/rpc.rs
+++ b/swap/src/rpc.rs
@@ -18,7 +18,7 @@ pub enum Error {
 
 pub async fn run_server(
     server_address: SocketAddr,
-    context: Arc<Context>,
+    context: Context,
 ) -> anyhow::Result<(SocketAddr, ServerHandle)> {
     let cors = CorsLayer::permissive();
     let middleware = tower::ServiceBuilder::new().layer(cors);
@@ -29,12 +29,7 @@ pub async fn run_server(
         .build(server_address)
         .await?;
 
-    let mut modules = RpcModule::new(());
-    {
-        modules
-            .merge(methods::register_modules(context)?)
-            .expect("Could not register RPC modules")
-    }
+    let modules = methods::register_modules(context)?;
 
     let addr = server.local_addr()?;
     let server_handle = server.start(modules)?;
diff --git a/swap/src/rpc/methods.rs b/swap/src/rpc/methods.rs
index d1f0b66c..ef17bad4 100644
--- a/swap/src/rpc/methods.rs
+++ b/swap/src/rpc/methods.rs
@@ -26,13 +26,11 @@ impl<T> ConvertToJsonRpseeError<T> for Result<T, anyhow::Error> {
     }
 }
 
-pub fn register_modules(outer_context: Arc<Context>) -> Result<RpcModule<Arc<Context>>> {
+pub fn register_modules(outer_context: Context) -> Result<RpcModule<Context>> {
     let mut module = RpcModule::new(outer_context);
 
     module.register_async_method("suspend_current_swap", |params, context| async move {
-        suspend_current_swap(Arc::unwrap_or_clone(context))
-            .await
-            .to_jsonrpsee_result()
+        suspend_current_swap(context).await.to_jsonrpsee_result()
     })?;
 
     module.register_async_method("get_swap_info", |params_raw, context| async move {
@@ -45,7 +43,7 @@ pub fn register_modules(outer_context: Arc<Context>) -> Result<RpcModule<Arc<Con
         let swap_id = as_uuid(swap_id)
             .ok_or_else(|| jsonrpsee_core::Error::Custom("Could not parse swap_id".to_string()))?;
 
-        get_swap_info(GetSwapInfoArgs { swap_id }, Arc::unwrap_or_clone(context))
+        get_swap_info(GetSwapInfoArgs { swap_id }, context)
             .await
             .to_jsonrpsee_result()
     })?;
@@ -63,21 +61,17 @@ pub fn register_modules(outer_context: Arc<Context>) -> Result<RpcModule<Arc<Con
                 jsonrpsee_core::Error::Custom("force_refesh is not a boolean".to_string())
             })?;
 
-        get_balance(BalanceArgs { force_refresh }, Arc::unwrap_or_clone(context))
+        get_balance(BalanceArgs { force_refresh }, context)
             .await
             .to_jsonrpsee_result()
     })?;
 
     module.register_async_method("get_history", |params, context| async move {
-        get_history(Arc::unwrap_or_clone(context))
-            .await
-            .to_jsonrpsee_result()
+        get_history(context).await.to_jsonrpsee_result()
     })?;
 
     module.register_async_method("get_raw_states", |params, context| async move {
-        get_raw_states(Arc::unwrap_or_clone(context))
-            .await
-            .to_jsonrpsee_result()
+        get_raw_states(context).await.to_jsonrpsee_result()
     })?;
 
     module.register_async_method("resume_swap", |params_raw, context| async move {
@@ -90,7 +84,7 @@ pub fn register_modules(outer_context: Arc<Context>) -> Result<RpcModule<Arc<Con
         let swap_id = as_uuid(swap_id)
             .ok_or_else(|| jsonrpsee_core::Error::Custom("Could not parse swap_id".to_string()))?;
 
-        resume_swap(ResumeArgs { swap_id }, Arc::unwrap_or_clone(context))
+        resume_swap(ResumeArgs { swap_id }, context)
             .await
             .to_jsonrpsee_result()
     })?;
@@ -105,12 +99,9 @@ pub fn register_modules(outer_context: Arc<Context>) -> Result<RpcModule<Arc<Con
         let swap_id = as_uuid(swap_id)
             .ok_or_else(|| jsonrpsee_core::Error::Custom("Could not parse swap_id".to_string()))?;
 
-        cancel_and_refund(
-            CancelAndRefundArgs { swap_id },
-            Arc::unwrap_or_clone(context),
-        )
-        .await
-        .to_jsonrpsee_result()
+        cancel_and_refund(CancelAndRefundArgs { swap_id }, context)
+            .await
+            .to_jsonrpsee_result()
     })?;
 
     module.register_async_method(
@@ -126,12 +117,9 @@ pub fn register_modules(outer_context: Arc<Context>) -> Result<RpcModule<Arc<Con
                 jsonrpsee_core::Error::Custom("Could not parse swap_id".to_string())
             })?;
 
-            monero_recovery(
-                MoneroRecoveryArgs { swap_id },
-                Arc::unwrap_or_clone(context),
-            )
-            .await
-            .to_jsonrpsee_result()
+            monero_recovery(MoneroRecoveryArgs { swap_id }, context)
+                .await
+                .to_jsonrpsee_result()
         },
     )?;
 
@@ -162,7 +150,7 @@ pub fn register_modules(outer_context: Arc<Context>) -> Result<RpcModule<Arc<Con
                 amount,
                 address: withdraw_address,
             },
-            Arc::unwrap_or_clone(context),
+            context,
         )
         .await
         .to_jsonrpsee_result()
@@ -206,7 +194,7 @@ pub fn register_modules(outer_context: Arc<Context>) -> Result<RpcModule<Arc<Con
                 monero_receive_address,
                 swap_id: Uuid::new_v4(),
             },
-            Arc::unwrap_or_clone(context),
+            context,
         )
         .await
         .to_jsonrpsee_result()
@@ -230,16 +218,14 @@ pub fn register_modules(outer_context: Arc<Context>) -> Result<RpcModule<Arc<Con
             ListSellersArgs {
                 rendezvous_point: rendezvous_point.clone(),
             },
-            Arc::unwrap_or_clone(context),
+            context,
         )
         .await
         .to_jsonrpsee_result()
     })?;
 
     module.register_async_method("get_current_swap", |params, context| async move {
-        get_current_swap(Arc::unwrap_or_clone(context))
-            .await
-            .to_jsonrpsee_result()
+        get_current_swap(context).await.to_jsonrpsee_result()
     })?;
 
     Ok(module)