diff --git a/bitcoin/src/iter.rs b/bitcoin/src/iter.rs
index 47976286e..12be7418e 100644
--- a/bitcoin/src/iter.rs
+++ b/bitcoin/src/iter.rs
@@ -200,6 +200,8 @@ mod tests {
             async fn is_block_known(&self, block_hash: BlockHash) -> Result<bool, Error>;
             async fn get_new_address<A: PartialAddress + Send + 'static>(&self) -> Result<A, Error>;
             async fn get_new_public_key<P: From<[u8; PUBLIC_KEY_SIZE]> + 'static>(&self) -> Result<P, Error>;
+            fn dump_derivation_key<P: Into<[u8; PUBLIC_KEY_SIZE]> + Send + Sync + 'static>(&self, public_key: P) -> Result<PrivateKey, Error>;
+            fn import_derivation_key(&self, private_key: &PrivateKey) -> Result<(), Error>;
             async fn add_new_deposit_key<P: Into<[u8; PUBLIC_KEY_SIZE]> + Send + Sync + 'static>(
                 &self,
                 public_key: P,
diff --git a/runtime/src/integration/bitcoin_simulator.rs b/runtime/src/integration/bitcoin_simulator.rs
index b3e03183f..c5b5375f2 100644
--- a/runtime/src/integration/bitcoin_simulator.rs
+++ b/runtime/src/integration/bitcoin_simulator.rs
@@ -362,6 +362,15 @@ impl BitcoinCoreApi for MockBitcoinCore {
         let public_key = PublicKey::from_secret_key(&secp, &secret_key);
         Ok(P::from(public_key.serialize()))
     }
+    fn dump_derivation_key<P: Into<[u8; PUBLIC_KEY_SIZE]> + Send + Sync + 'static>(
+        &self,
+        public_key: P,
+    ) -> Result<PrivateKey, BitcoinError> {
+        todo!()
+    }
+    fn import_derivation_key(&self, private_key: &PrivateKey) -> Result<(), BitcoinError> {
+        todo!()
+    }
     async fn add_new_deposit_key<P: Into<[u8; PUBLIC_KEY_SIZE]> + Send + Sync + 'static>(
         &self,
         _public_key: P,
diff --git a/vault/src/collateral.rs b/vault/src/collateral.rs
index a670e68a8..c688c9db6 100644
--- a/vault/src/collateral.rs
+++ b/vault/src/collateral.rs
@@ -207,7 +207,6 @@ mod tests {
                 id: x.clone(),
                 wallet: Wallet {
                     addresses: Default::default(),
-                    public_key: BtcPublicKey { 0: [0; 33] },
                 },
                 status: VaultStatus::Active(true),
                 banned_until: None,
@@ -338,7 +337,6 @@ mod tests {
                 id: x.clone(),
                 wallet: Wallet {
                     addresses: Default::default(),
-                    public_key: BtcPublicKey { 0: [0; 33] },
                 },
                 status: VaultStatus::CommittedTheft,
                 banned_until: None,
diff --git a/vault/src/execution.rs b/vault/src/execution.rs
index c7630a6a4..2435ad272 100644
--- a/vault/src/execution.rs
+++ b/vault/src/execution.rs
@@ -668,6 +668,8 @@ mod tests {
             async fn is_block_known(&self, block_hash: BlockHash) -> Result<bool, BitcoinError>;
             async fn get_new_address<A: PartialAddress + Send + 'static>(&self) -> Result<A, BitcoinError>;
             async fn get_new_public_key<P: From<[u8; PUBLIC_KEY_SIZE]> + 'static>(&self) -> Result<P, BitcoinError>;
+            fn dump_derivation_key<P: Into<[u8; PUBLIC_KEY_SIZE]> + Send + Sync + 'static>(&self, public_key: P) -> Result<PrivateKey, BitcoinError>;
+            fn import_derivation_key(&self, private_key: &PrivateKey) -> Result<(), BitcoinError>;
             async fn add_new_deposit_key<P: Into<[u8; PUBLIC_KEY_SIZE]> + Send + Sync + 'static>(&self, public_key: P, secret_key: Vec<u8>) -> Result<(), BitcoinError>;
             async fn get_best_block_hash(&self) -> Result<BlockHash, BitcoinError>;
             async fn get_block(&self, hash: &BlockHash) -> Result<Block, BitcoinError>;
diff --git a/vault/src/metrics.rs b/vault/src/metrics.rs
index 0c8607daf..b54b09e2f 100644
--- a/vault/src/metrics.rs
+++ b/vault/src/metrics.rs
@@ -726,7 +726,7 @@ mod tests {
             async fn get_vault(&self, vault_id: &VaultId) -> Result<InterBtcVault, RuntimeError>;
             async fn get_vaults_by_account_id(&self, account_id: &AccountId) -> Result<Vec<VaultId>, RuntimeError>;
             async fn get_all_vaults(&self) -> Result<Vec<InterBtcVault>, RuntimeError>;
-            async fn register_vault(&self, vault_id: &VaultId, collateral: u128, public_key: BtcPublicKey) -> Result<(), RuntimeError>;
+            async fn register_vault(&self, vault_id: &VaultId, collateral: u128) -> Result<(), RuntimeError>;
             async fn deposit_collateral(&self, vault_id: &VaultId, amount: u128) -> Result<(), RuntimeError>;
             async fn withdraw_collateral(&self, vault_id: &VaultId, amount: u128) -> Result<(), RuntimeError>;
             async fn get_public_key(&self) -> Result<Option<BtcPublicKey>, RuntimeError>;
@@ -803,6 +803,8 @@ mod tests {
             async fn is_block_known(&self, block_hash: BlockHash) -> Result<bool, BitcoinError>;
             async fn get_new_address<A: PartialAddress + Send + 'static>(&self) -> Result<A, BitcoinError>;
             async fn get_new_public_key<P: From<[u8; PUBLIC_KEY_SIZE]> + 'static>(&self) -> Result<P, BitcoinError>;
+            fn dump_derivation_key<P: Into<[u8; PUBLIC_KEY_SIZE]> + Send + Sync + 'static>(&self, public_key: P) -> Result<PrivateKey, BitcoinError>;
+            fn import_derivation_key(&self, private_key: &PrivateKey) -> Result<(), BitcoinError>;
             async fn add_new_deposit_key<P: Into<[u8; PUBLIC_KEY_SIZE]> + Send + Sync + 'static>(&self, public_key: P, secret_key: Vec<u8>) -> Result<(), BitcoinError>;
             async fn get_best_block_hash(&self) -> Result<BlockHash, BitcoinError>;
             async fn get_block(&self, hash: &BlockHash) -> Result<Block, BitcoinError>;
@@ -924,7 +926,6 @@ mod tests {
                 id: x.clone(),
                 wallet: Wallet {
                     addresses: Default::default(),
-                    public_key: BtcPublicKey { 0: [0; 33] },
                 },
                 status: VaultStatus::Active(true),
                 banned_until: None,
diff --git a/vault/src/replace.rs b/vault/src/replace.rs
index de9792413..3bf8d4ac9 100644
--- a/vault/src/replace.rs
+++ b/vault/src/replace.rs
@@ -243,6 +243,8 @@ mod tests {
             async fn is_block_known(&self, block_hash: BlockHash) -> Result<bool, BitcoinError>;
             async fn get_new_address<A: PartialAddress + Send + 'static>(&self) -> Result<A, BitcoinError>;
             async fn get_new_public_key<P: From<[u8; PUBLIC_KEY_SIZE]> + 'static>(&self) -> Result<P, BitcoinError>;
+            fn dump_derivation_key<P: Into<[u8; PUBLIC_KEY_SIZE]> + Send + Sync + 'static>(&self, public_key: P) -> Result<PrivateKey, BitcoinError>;
+            fn import_derivation_key(&self, private_key: &PrivateKey) -> Result<(), BitcoinError>;
             async fn add_new_deposit_key<P: Into<[u8; PUBLIC_KEY_SIZE]> + Send + Sync + 'static>(
                 &self,
                 public_key: P,
diff --git a/vault/src/vaults.rs b/vault/src/vaults.rs
index 69263a3ee..4213179af 100644
--- a/vault/src/vaults.rs
+++ b/vault/src/vaults.rs
@@ -333,6 +333,8 @@ mod tests {
             async fn is_block_known(&self, block_hash: BlockHash) -> Result<bool, BitcoinError>;
             async fn get_new_address<A: PartialAddress + Send + 'static>(&self) -> Result<A, BitcoinError>;
             async fn get_new_public_key<P: From<[u8; PUBLIC_KEY_SIZE]> + 'static>(&self) -> Result<P, BitcoinError>;
+            fn dump_derivation_key<P: Into<[u8; PUBLIC_KEY_SIZE]> + Send + Sync + 'static>(&self, public_key: P) -> Result<PrivateKey, BitcoinError>;
+            fn import_derivation_key(&self, private_key: &PrivateKey) -> Result<(), BitcoinError>;
             async fn add_new_deposit_key<P: Into<[u8; PUBLIC_KEY_SIZE]> + Send + Sync + 'static>(
                 &self,
                 public_key: P,
diff --git a/vault/tests/vault_integration_tests.rs b/vault/tests/vault_integration_tests.rs
index e047b95ee..1ddeb2dc6 100644
--- a/vault/tests/vault_integration_tests.rs
+++ b/vault/tests/vault_integration_tests.rs
@@ -1,5 +1,6 @@
 #![cfg(feature = "standalone-metadata")]
 
+use async_trait::async_trait;
 use bitcoin::{stream_blocks, BitcoinCoreApi, TransactionExt};
 use frame_support::assert_ok;
 use futures::{
@@ -192,7 +193,7 @@ async fn test_report_vault_theft_succeeds() {
         get_required_vault_collateral_for_issue(&vault_provider, issue_amount, vault_id.collateral_currency()).await;
     assert_ok!(
         vault_provider
-            .register_vault(&vault_id, vault_collateral, btc_rpc.get_new_public_key().await.unwrap(),)
+            .register_vault_with_public_key(&vault_id, vault_collateral, btc_rpc.get_new_public_key().await.unwrap(),)
             .await
     );
 
@@ -271,7 +272,11 @@ async fn test_report_vault_double_payment_succeeds() {
                 .await;
         assert_ok!(
             vault_provider
-                .register_vault(&vault_id, vault_collateral, btc_rpc.get_new_public_key().await.unwrap(),)
+                .register_vault_with_public_key(
+                    &vault_id,
+                    vault_collateral,
+                    btc_rpc.get_new_public_key().await.unwrap(),
+                )
                 .await
         );
         assert_issue(&user_provider, &btc_rpc, &vault_id, issue_amount).await;
@@ -302,6 +307,10 @@ async fn test_report_vault_double_payment_succeeds() {
     .await;
 }
 
+async fn get_master_btc_rpc(parachain_rpc: InterBtcParachain) -> MockBitcoinCore {
+    let btc_rpc = MockBitcoinCore::new(parachain_rpc).await;
+    btc_rpc
+}
 #[tokio::test(flavor = "multi_thread")]
 async fn test_redeem_succeeds() {
     test_with_vault(|client, vault_id, vault_provider| async move {
@@ -310,7 +319,8 @@ async fn test_redeem_succeeds() {
 
         let btc_rpc = MockBitcoinCore::new(relayer_provider.clone()).await;
         let btc_rpcs = vec![(vault_id.clone(), btc_rpc.clone())].into_iter().collect();
-        let vault_id_manager = VaultIdManager::from_map(vault_provider.clone(), btc_rpcs);
+        let btc_rpc_master_wallet = btc_rpc.clone();
+        let vault_id_manager = VaultIdManager::from_map(vault_provider.clone(), btc_rpc_master_wallet, btc_rpcs);
 
         let issue_amount = 100000;
         let vault_collateral =
@@ -318,7 +328,11 @@ async fn test_redeem_succeeds() {
                 .await;
         assert_ok!(
             vault_provider
-                .register_vault(&vault_id, vault_collateral, btc_rpc.get_new_public_key().await.unwrap(),)
+                .register_vault_with_public_key(
+                    &vault_id,
+                    vault_collateral,
+                    btc_rpc.get_new_public_key().await.unwrap(),
+                )
                 .await
         );
 
@@ -360,14 +374,18 @@ async fn test_replace_succeeds() {
 
         let btc_rpc = MockBitcoinCore::new(relayer_provider.clone()).await;
         let btc_rpcs = vec![(new_vault_id.clone(), btc_rpc.clone())].into_iter().collect();
-        let _vault_id_manager = VaultIdManager::from_map(new_vault_provider.clone(), btc_rpcs);
+        let new_btc_rpc_master_wallet = btc_rpc.clone();
+        let _vault_id_manager =
+            VaultIdManager::from_map(new_vault_provider.clone(), new_btc_rpc_master_wallet, btc_rpcs);
         let btc_rpcs = vec![
             (old_vault_id.clone(), btc_rpc.clone()),
             (new_vault_id.clone(), btc_rpc.clone()),
         ]
         .into_iter()
         .collect();
-        let vault_id_manager = VaultIdManager::from_map(old_vault_provider.clone(), btc_rpcs);
+        let old_btc_rpc_master_wallet = btc_rpc.clone();
+        let vault_id_manager =
+            VaultIdManager::from_map(old_vault_provider.clone(), old_btc_rpc_master_wallet, btc_rpcs);
 
         let issue_amount = 100000;
         let vault_collateral = get_required_vault_collateral_for_issue(
@@ -378,7 +396,7 @@ async fn test_replace_succeeds() {
         .await;
         assert_ok!(
             old_vault_provider
-                .register_vault(
+                .register_vault_with_public_key(
                     &old_vault_id,
                     vault_collateral,
                     btc_rpc.get_new_public_key().await.unwrap(),
@@ -387,7 +405,7 @@ async fn test_replace_succeeds() {
         );
         assert_ok!(
             new_vault_provider
-                .register_vault(
+                .register_vault_with_public_key(
                     &new_vault_id,
                     vault_collateral,
                     btc_rpc.get_new_public_key().await.unwrap(),
@@ -449,7 +467,8 @@ async fn test_maintain_collateral_succeeds() {
 
         let btc_rpc = MockBitcoinCore::new(relayer_provider.clone()).await;
         let btc_rpcs = vec![(vault_id.clone(), btc_rpc.clone())].into_iter().collect();
-        let vault_id_manager = VaultIdManager::from_map(vault_provider.clone(), btc_rpcs);
+        let btc_rpc_master_wallet = btc_rpc.clone();
+        let vault_id_manager = VaultIdManager::from_map(vault_provider.clone(), btc_rpc_master_wallet, btc_rpcs);
 
         let issue_amount = 100000;
         let vault_collateral =
@@ -457,7 +476,11 @@ async fn test_maintain_collateral_succeeds() {
                 .await;
         assert_ok!(
             vault_provider
-                .register_vault(&vault_id, vault_collateral, btc_rpc.get_new_public_key().await.unwrap(),)
+                .register_vault_with_public_key(
+                    &vault_id,
+                    vault_collateral,
+                    btc_rpc.get_new_public_key().await.unwrap(),
+                )
                 .await
         );
 
@@ -509,7 +532,7 @@ async fn test_withdraw_replace_succeeds() {
         .await;
         assert_ok!(
             old_vault_provider
-                .register_vault(
+                .register_vault_with_public_key(
                     &old_vault_id,
                     vault_collateral,
                     btc_rpc.get_new_public_key().await.unwrap(),
@@ -518,7 +541,7 @@ async fn test_withdraw_replace_succeeds() {
         );
         assert_ok!(
             new_vault_provider
-                .register_vault(
+                .register_vault_with_public_key(
                     &new_vault_id,
                     vault_collateral,
                     btc_rpc.get_new_public_key().await.unwrap(),
@@ -574,7 +597,9 @@ async fn test_cancellation_succeeds() {
 
         let btc_rpc = MockBitcoinCore::new(relayer_provider.clone()).await;
         let btc_rpcs = vec![(new_vault_id.clone(), btc_rpc.clone())].into_iter().collect();
-        let vault_id_manager = VaultIdManager::from_map(new_vault_provider.clone(), btc_rpcs);
+        let new_btc_rpc_master_wallet = btc_rpc.clone();
+        let vault_id_manager =
+            VaultIdManager::from_map(new_vault_provider.clone(), new_btc_rpc_master_wallet, btc_rpcs);
 
         let issue_amount = 100000;
         let vault_collateral = get_required_vault_collateral_for_issue(
@@ -585,7 +610,7 @@ async fn test_cancellation_succeeds() {
         .await;
         assert_ok!(
             old_vault_provider
-                .register_vault(
+                .register_vault_with_public_key(
                     &old_vault_id,
                     vault_collateral,
                     btc_rpc.get_new_public_key().await.unwrap(),
@@ -594,7 +619,7 @@ async fn test_cancellation_succeeds() {
         );
         assert_ok!(
             new_vault_provider
-                .register_vault(
+                .register_vault_with_public_key(
                     &new_vault_id,
                     vault_collateral,
                     btc_rpc.get_new_public_key().await.unwrap(),
@@ -760,7 +785,8 @@ async fn test_refund_succeeds() {
 
         let btc_rpc = MockBitcoinCore::new(relayer_provider.clone()).await;
         let btc_rpcs = vec![(vault_id.clone(), btc_rpc.clone())].into_iter().collect();
-        let vault_id_manager = VaultIdManager::from_map(vault_provider.clone(), btc_rpcs);
+        let btc_rpc_master_wallet = btc_rpc.clone();
+        let vault_id_manager = VaultIdManager::from_map(vault_provider.clone(), btc_rpc_master_wallet, btc_rpcs);
 
         let (shutdown_tx, _) = tokio::sync::broadcast::channel(16);
         let refund_service =
@@ -774,7 +800,11 @@ async fn test_refund_succeeds() {
                 .await;
         assert_ok!(
             vault_provider
-                .register_vault(&vault_id, vault_collateral, btc_rpc.get_new_public_key().await.unwrap(),)
+                .register_vault_with_public_key(
+                    &vault_id,
+                    vault_collateral,
+                    btc_rpc.get_new_public_key().await.unwrap(),
+                )
                 .await
         );
 
@@ -839,7 +869,8 @@ async fn test_issue_overpayment_succeeds() {
 
         let btc_rpc = MockBitcoinCore::new(relayer_provider.clone()).await;
         let btc_rpcs = vec![(vault_id.clone(), btc_rpc.clone())].into_iter().collect();
-        let vault_id_manager = VaultIdManager::from_map(vault_provider.clone(), btc_rpcs);
+        let btc_rpc_master_wallet = btc_rpc.clone();
+        let vault_id_manager = VaultIdManager::from_map(vault_provider.clone(), btc_rpc_master_wallet, btc_rpcs);
 
         let (shutdown_tx, _) = tokio::sync::broadcast::channel(16);
         let refund_service =
@@ -855,7 +886,11 @@ async fn test_issue_overpayment_succeeds() {
         .await;
         assert_ok!(
             vault_provider
-                .register_vault(&vault_id, vault_collateral, btc_rpc.get_new_public_key().await.unwrap(),)
+                .register_vault_with_public_key(
+                    &vault_id,
+                    vault_collateral,
+                    btc_rpc.get_new_public_key().await.unwrap(),
+                )
                 .await
         );
 
@@ -911,7 +946,8 @@ async fn test_automatic_issue_execution_succeeds() {
 
         let btc_rpc = MockBitcoinCore::new(relayer_provider.clone()).await;
         let btc_rpcs = vec![(vault2_id.clone(), btc_rpc.clone())].into_iter().collect();
-        let vault_id_manager = VaultIdManager::from_map(vault2_provider.clone(), btc_rpcs);
+        let btc_rpc_master_wallet = btc_rpc.clone();
+        let vault_id_manager = VaultIdManager::from_map(vault2_provider.clone(), btc_rpc_master_wallet, btc_rpcs);
 
         let issue_amount = 100000;
         let vault_collateral =
@@ -919,7 +955,7 @@ async fn test_automatic_issue_execution_succeeds() {
                 .await;
         assert_ok!(
             vault1_provider
-                .register_vault(
+                .register_vault_with_public_key(
                     &vault1_id,
                     vault_collateral,
                     btc_rpc.get_new_public_key().await.unwrap(),
@@ -928,7 +964,7 @@ async fn test_automatic_issue_execution_succeeds() {
         );
         assert_ok!(
             vault2_provider
-                .register_vault(
+                .register_vault_with_public_key(
                     &vault2_id,
                     vault_collateral,
                     btc_rpc.get_new_public_key().await.unwrap(),
@@ -987,7 +1023,8 @@ async fn test_automatic_issue_execution_succeeds_with_big_transaction() {
 
         let btc_rpc = MockBitcoinCore::new(relayer_provider.clone()).await;
         let btc_rpcs = vec![(vault2_id.clone(), btc_rpc.clone())].into_iter().collect();
-        let vault_id_manager = VaultIdManager::from_map(vault2_provider.clone(), btc_rpcs);
+        let btc_rpc_master_wallet = btc_rpc.clone();
+        let vault_id_manager = VaultIdManager::from_map(vault2_provider.clone(), btc_rpc_master_wallet, btc_rpcs);
 
         let issue_amount = 100000;
         let vault_collateral =
@@ -995,7 +1032,7 @@ async fn test_automatic_issue_execution_succeeds_with_big_transaction() {
                 .await;
         assert_ok!(
             vault1_provider
-                .register_vault(
+                .register_vault_with_public_key(
                     &vault1_id,
                     vault_collateral,
                     btc_rpc.get_new_public_key().await.unwrap(),
@@ -1004,7 +1041,7 @@ async fn test_automatic_issue_execution_succeeds_with_big_transaction() {
         );
         assert_ok!(
             vault2_provider
-                .register_vault(
+                .register_vault_with_public_key(
                     &vault2_id,
                     vault_collateral,
                     btc_rpc.get_new_public_key().await.unwrap(),
@@ -1055,7 +1092,8 @@ async fn test_execute_open_requests_succeeds() {
 
         let btc_rpc = MockBitcoinCore::new(relayer_provider.clone()).await;
         let btc_rpcs = vec![(vault_id.clone(), btc_rpc.clone())].into_iter().collect();
-        let vault_id_manager = VaultIdManager::from_map(vault_provider.clone(), btc_rpcs);
+        let btc_rpc_master_wallet = btc_rpc.clone();
+        let vault_id_manager = VaultIdManager::from_map(vault_provider.clone(), btc_rpc_master_wallet, btc_rpcs);
 
         let issue_amount = 100000;
         let vault_collateral =
@@ -1063,7 +1101,11 @@ async fn test_execute_open_requests_succeeds() {
                 .await;
         assert_ok!(
             vault_provider
-                .register_vault(&vault_id, vault_collateral, btc_rpc.get_new_public_key().await.unwrap(),)
+                .register_vault_with_public_key(
+                    &vault_id,
+                    vault_collateral,
+                    btc_rpc.get_new_public_key().await.unwrap(),
+                )
                 .await
         );
 
@@ -1137,7 +1179,11 @@ async fn test_off_chain_liquidation() {
                 .await;
         assert_ok!(
             vault_provider
-                .register_vault(&vault_id, vault_collateral, btc_rpc.get_new_public_key().await.unwrap(),)
+                .register_vault_with_public_key(
+                    &vault_id,
+                    vault_collateral,
+                    btc_rpc.get_new_public_key().await.unwrap(),
+                )
                 .await
         );
 
@@ -1165,7 +1211,7 @@ async fn test_shutdown() {
         let btc_rpc = MockBitcoinCore::new(sudo_provider.clone()).await;
         assert_ok!(
             sudo_provider
-                .register_vault(&sudo_vault_id, 1000000, btc_rpc.get_new_public_key().await.unwrap(),)
+                .register_vault_with_public_key(&sudo_vault_id, 1000000, btc_rpc.get_new_public_key().await.unwrap(),)
                 .await
         );