feat: add random keypair generation to receive (#255)

* feat: add random keypair generation to receive
* feat: add `get_claim_keypair` method to swap

lib/core/src/model.rs

@@ -270,6 +270,7 @@ pub(crate) struct ReceiveSwap {
     pub(crate) preimage: String,
     /// JSON representation of [crate::persist::receive::InternalCreateReverseResponse]
     pub(crate) create_response_json: String,
+    pub(crate) claim_private_key: String,
     pub(crate) invoice: String,
     /// The amount of the invoice
     pub(crate) payer_amount_sat: u64,
@@ -281,6 +282,10 @@ pub(crate) struct ReceiveSwap {
     pub(crate) state: PaymentState,
 }
 impl ReceiveSwap {
+    pub(crate) fn get_claim_keypair(&self) -> Result<Keypair, PaymentError> {
+        utils::decode_keypair(&self.claim_private_key).map_err(Into::into)
+    }
+
     pub(crate) fn get_boltz_create_response(&self) -> Result<CreateReverseResponse, PaymentError> {
         let internal_create_response: crate::persist::receive::InternalCreateReverseResponse =
             serde_json::from_str(&self.create_response_json).map_err(|e| {

lib/core/src/persist/migrations.rs

@@ -4,6 +4,7 @@ pub(crate) fn current_migrations() -> Vec<&'static str> {
             id TEXT NOT NULL PRIMARY KEY,
             preimage TEXT NOT NULL,
             create_response_json TEXT NOT NULL,
+            claim_private_key TEXT NOT NULL,
             invoice TEXT NOT NULL,
             payer_amount_sat INTEGER NOT NULL,
             receiver_amount_sat INTEGER NOT NULL,

lib/core/src/persist/receive.rs

@@ -20,6 +20,7 @@ impl Persister {
                 id,
                 preimage,
                 create_response_json,
+                claim_private_key,
                 invoice,
                 payer_amount_sat,
                 receiver_amount_sat,
@@ -28,12 +29,13 @@ impl Persister {
                 claim_tx_id,
                 state
             )
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
         )?;
         _ = stmt.execute((
             &receive_swap.id,
             &receive_swap.preimage,
             &receive_swap.create_response_json,
+            &receive_swap.claim_private_key,
             &receive_swap.invoice,
             &receive_swap.payer_amount_sat,
             &receive_swap.receiver_amount_sat,
@@ -59,6 +61,7 @@ impl Persister {
                 rs.id,
                 rs.preimage,
                 rs.create_response_json,
+                rs.claim_private_key,
                 rs.invoice,
                 rs.payer_amount_sat,
                 rs.receiver_amount_sat,
@@ -86,13 +89,14 @@ impl Persister {
             id: row.get(0)?,
             preimage: row.get(1)?,
             create_response_json: row.get(2)?,
-            invoice: row.get(3)?,
-            payer_amount_sat: row.get(4)?,
-            receiver_amount_sat: row.get(5)?,
-            claim_fees_sat: row.get(6)?,
-            claim_tx_id: row.get(7)?,
-            created_at: row.get(8)?,
-            state: row.get(9)?,
+            claim_private_key: row.get(3)?,
+            invoice: row.get(4)?,
+            payer_amount_sat: row.get(5)?,
+            receiver_amount_sat: row.get(6)?,
+            claim_fees_sat: row.get(7)?,
+            claim_tx_id: row.get(8)?,
+            created_at: row.get(9)?,
+            state: row.get(10)?,
         })
     }
 

lib/core/src/sdk.rs

@@ -19,7 +19,7 @@ use boltz_client::{
         boltzv2::*,
         liquidv2::LBtcSwapTxV2,
     },
-    util::secrets::{LiquidSwapKey, Preimage, SwapKey},
+    util::secrets::Preimage,
     Amount, Bolt11Invoice, ElementsAddress, Keypair, LBtcSwapScriptV2,
 };
 use log::{debug, error, info, warn};
@@ -1073,13 +1073,11 @@ impl LiquidSdk {
         self.try_handle_receive_swap_update(swap_id, Pending, None)
             .await?;
 
-        let lsk = self.get_liquid_swap_key()?;
-        let our_keys = lsk.keypair;
-
+        let keypair = ongoing_receive_swap.get_claim_keypair()?;
         let create_response = ongoing_receive_swap.get_boltz_create_response()?;
         let swap_script = LBtcSwapScriptV2::reverse_from_swap_resp(
             &create_response,
-            our_keys.public_key().into(),
+            keypair.public_key().into(),
         )?;
 
         let claim_address = self.next_unused_address().await?.to_string();
@@ -1092,7 +1090,7 @@ impl LiquidSdk {
         )?;
 
         let claim_tx = claim_tx_wrapper.sign_claim(
-            &our_keys,
+            &keypair,
             &Preimage::from_str(&ongoing_receive_swap.preimage)?,
             Amount::from_sat(ongoing_receive_swap.claim_fees_sat),
             // Enable cooperative claim (Some) or not (None)
@@ -1173,7 +1171,7 @@ impl LiquidSdk {
 
         debug!("Creating Receive Swap with: payer_amount_sat {payer_amount_sat} sat, fees_sat {fees_sat} sat");
 
-        let lsk = self.get_liquid_swap_key()?;
+        let keypair = utils::generate_keypair();
 
         let preimage = Preimage::new();
         let preimage_str = preimage.to_string().ok_or(PaymentError::InvalidPreimage)?;
@@ -1184,7 +1182,7 @@ impl LiquidSdk {
             from: "BTC".to_string(),
             to: "L-BTC".to_string(),
             preimage_hash: preimage.sha256,
-            claim_public_key: lsk.keypair.public_key().into(),
+            claim_public_key: keypair.public_key().into(),
             address: None,
             address_signature: None,
             referral_id: None,
@@ -1215,6 +1213,7 @@ impl LiquidSdk {
                 id: swap_id.clone(),
                 preimage: preimage_str,
                 create_response_json,
+                claim_private_key: keypair.display_secret().to_string(),
                 invoice: invoice.to_string(),
                 payer_amount_sat,
                 receiver_amount_sat: payer_amount_sat - req.fees_sat,
@@ -1397,20 +1396,6 @@ impl LiquidSdk {
         self.persister.restore_from_backup(backup_path)
     }
 
-    fn get_liquid_swap_key(&self) -> Result<LiquidSwapKey, PaymentError> {
-        let mnemonic = self
-            .lwk_signer
-            .mnemonic()
-            .ok_or(PaymentError::SignerError {
-                err: "Mnemonic not found".to_string(),
-            })?;
-        let swap_key =
-            SwapKey::from_reverse_account(&mnemonic.to_string(), "", self.network.into(), 0)?;
-        LiquidSwapKey::try_from(swap_key).map_err(|e| PaymentError::SignerError {
-            err: format!("Could not create LiquidSwapKey: {e:?}"),
-        })
-    }
-
     pub fn parse_invoice(input: &str) -> Result<LNInvoice, PaymentError> {
         let input = input
             .strip_prefix("lightning:")