feat(taker): import seed

Author: holzeis

crates/daemon-tests/src/mocks/wallet.rs

@@ -52,6 +52,9 @@ impl WalletActor {
     async fn handle(&mut self, msg: wallet::Sync) {
         self.mock.lock().await.sync(msg)
     }
+    async fn handle(&mut self, msg: wallet::ImportSeed) -> Result<()> {
+        self.mock.lock().await.import_seed(msg)
+    }
 }
 
 #[automock]
@@ -71,6 +74,10 @@ pub trait Wallet {
     fn sync(&mut self, _msg: wallet::Sync) {
         unreachable!("mockall will reimplement this method")
     }
+
+    fn import_seed(&mut self, _msg: wallet::ImportSeed) -> Result<()> {
+        unreachable!("mockall will reimplement this method")
+    }
 }
 
 pub fn build_party_params(msg: wallet::BuildPartyParams) -> Result<PartyParams> {

crates/daemon-tests/tests/main/import_seed.rs

@@ -0,0 +1,40 @@
+use daemon::bdk::bitcoin;
+use daemon::seed::RandomSeed;
+use daemon::seed::Seed;
+use daemon_tests::open_cfd;
+use daemon_tests::start_both;
+use daemon_tests::OpenCfdArgs;
+use otel_tests::otel_test;
+use rand::distributions::Alphanumeric;
+use rand::thread_rng;
+use rand::Rng;
+use std::env;
+use std::path::Path;
+
+#[otel_test]
+async fn fail_to_import_seed_with_open_cfds() {
+    let (mut maker, mut taker) = start_both().await;
+
+    let cfd_args = OpenCfdArgs::default();
+    open_cfd(&mut taker, &mut maker, cfd_args.clone()).await;
+
+    let random_folder: String = thread_rng()
+        .sample_iter(&Alphanumeric)
+        .take(7)
+        .map(char::from)
+        .collect();
+    let data_dir = env::temp_dir().join(Path::new(&random_folder));
+    tokio::fs::create_dir_all(&data_dir)
+        .await
+        .expect("failed to create random temp folder");
+
+    taker
+        .system
+        .import_seed(
+            RandomSeed::default().seed(),
+            data_dir,
+            bitcoin::Network::Testnet,
+        )
+        .await
+        .expect_err("import seed should be rejected as open CFDs exist");
+}

crates/daemon-tests/tests/main/main.rs

@@ -1,5 +1,6 @@
 mod collaborative_settlement;
 mod connectivity;
+mod import_seed;
 mod liquidation;
 mod non_collaborative_settlement;
 mod offer;

crates/daemon/src/lib.rs

@@ -1,8 +1,10 @@
 #![cfg_attr(not(test), warn(clippy::unwrap_used))]
 
 use crate::bitcoin::util::psbt::PartiallySignedTransaction;
+use crate::bitcoin::Network;
 use crate::bitcoin::Txid;
 use crate::listen_protocols::TAKER_LISTEN_PROTOCOLS;
+use anyhow::anyhow;
 use anyhow::bail;
 use anyhow::Context as _;
 use anyhow::Result;
@@ -30,7 +32,9 @@ use parse_display::Display;
 use ping_pong::ping;
 use ping_pong::pong;
 use seed::Identities;
+use serde::Serialize;
 use std::collections::HashSet;
+use std::path::PathBuf;
 use std::sync::Arc;
 use std::time::Duration;
 use time::ext::NumericalDuration;
@@ -78,7 +82,7 @@ pub const N_PAYOUTS: usize = 200;
 
 pub struct TakerActorSystem<O, W, P> {
     pub cfd_actor: Address<taker_cfd::Actor>,
-    wallet_actor: Address<W>,
+    pub wallet_actor: Address<W>,
     _oracle_actor: Address<O>,
     pub auto_rollover_actor: Address<auto_rollover::Actor>,
     pub price_feed_actor: Address<P>,
@@ -93,6 +97,8 @@ pub struct TakerActorSystem<O, W, P> {
     pub identify_info_feed_receiver: watch::Receiver<Option<PeerInfo>>,
 
     _tasks: Tasks,
+
+    db: sqlite_db::Connection,
 }
 
 impl<O, W, P> TakerActorSystem<O, W, P>
@@ -105,6 +111,7 @@ where
     W: Handler<wallet::BuildPartyParams, Return = Result<maia_core::PartyParams>>
         + Handler<wallet::Sign, Return = Result<PartiallySignedTransaction>>
         + Handler<wallet::Withdraw, Return = Result<Txid>>
+        + Handler<wallet::ImportSeed, Return = Result<()>>
         + Handler<wallet::Sync, Return = ()>
         + Actor<Stop = ()>,
     P: Handler<
@@ -333,7 +340,7 @@ where
         let close_cfds_actor = archive_closed_cfds::Actor::new(db.clone())
             .create(None)
             .spawn(&mut tasks);
-        let archive_failed_cfds_actor = archive_failed_cfds::Actor::new(db)
+        let archive_failed_cfds_actor = archive_failed_cfds::Actor::new(db.clone())
             .create(None)
             .spawn(&mut tasks);
 
@@ -354,6 +361,7 @@ where
             _online_status_actor: online_status_actor,
             _pong_actor: pong_address,
             _identify_dialer_actor: identify_dialer_actor,
+            db,
         })
     }
 
@@ -445,14 +453,46 @@ where
         self.wallet_actor.send(wallet::Sync).await?;
         Ok(())
     }
+
+    #[instrument(skip(self, seed), err)]
+    pub async fn import_seed(
+        &self,
+        seed: Vec<u8>,
+        data_dir: PathBuf,
+        network: Network,
+    ) -> Result<()> {
+        let open_cfd_ids = self.db.load_open_cfd_ids().await?;
+
+        if !open_cfd_ids.is_empty() {
+            tracing::warn!("Rejecting imported seed as open CFDs exist.");
+            // in case of open cfds we do not accept an imported seed.
+            return Err(anyhow!(
+                "Can not accept imported seed since open CFDs exist."
+            ));
+        }
+
+        // recreate the wallet within the wallet actor
+        self.wallet_actor
+            .send(wallet::ImportSeed {
+                seed,
+                seed_path: data_dir.join(seed::TAKER_WALLET_SEED_FILE),
+                network,
+            })
+            .await??;
+
+        // sync imported wallet
+        self.wallet_actor.send(wallet::Sync).await?;
+
+        Ok(())
+    }
 }
 
 /// A struct defining our environment
 ///
 /// We can run on all kinds of environment, hence this is just a wrapper around string.
 /// However, for backwards compatibility with <=0.6.x we need to support to support
 /// `Unknown`. For all other we format the string to lowercase.
-#[derive(Debug, Clone, Display, PartialEq, Eq)]
+#[derive(Debug, Clone, Display, PartialEq, Eq, Serialize)]
 pub struct Environment(String);
 
 impl Environment {

crates/daemon/src/seed.rs

@@ -30,7 +30,15 @@ impl Identities {
     }
 }
 
+pub const TAKER_WALLET_SEED_FILE: &str = "taker_seed";
+pub const TAKER_IDENTITY_SEED_FILE: &str = "taker_id_seed";
+
+pub const MAKER_WALLET_SEED_FILE: &str = "maker_seed";
+pub const MAKER_IDENTITY_SEED_FILE: &str = "maker_id_seed";
+
 pub trait Seed {
+
+
     fn seed(&self) -> Vec<u8>;
 
     fn derive_extended_priv_key(&self, network: Network) -> Result<ExtendedPrivKey> {
@@ -133,6 +141,12 @@ impl RandomSeed {
     }
 }
 
+impl From<[u8; 256]> for RandomSeed {
+    fn from(bytes: [u8; 256]) -> Self {
+        Self(bytes)
+    }
+}
+
 impl Default for RandomSeed {
     fn default() -> Self {
         let mut seed = [0u8; 256];