Extract stateless functions into wallet library module

Author: rishflab

bobtimus/src/lib.rs

@@ -327,19 +327,20 @@ where
         )
         .unwrap();
 
+        let elementsd_client = self.elementsd.clone();
+        |amount, asset| async move { Self::find_inputs(&elementsd_client, asset, amount).await };
+
         let lender1 = lender0
-            .interpret(
+            .build_loan_transaction(
                 &mut self.rng,
                 &SECP256K1,
-                {
-                    let elementsd_client = self.elementsd.clone();
-                    |amount, asset| async move {
-                        Self::find_inputs(&elementsd_client, asset, amount).await
-                    }
-                },
-                payload.into(),
+                todo!(),
+                (payload.collateral_amount, payload.collateral_inputs),
+                todo!(),
+                todo!(),
+                todo!(),
+                (payload.borrower_pk, payload.borrower_address),
                 timelock,
-                self.rate_service.latest_rate().bid.as_satodollar(),
             )
             .await
             .unwrap();

bobtimus/src/loan.rs

@@ -63,23 +63,11 @@ pub struct Interest {
 pub struct LoanRequest {
     #[serde(with = "::elements::bitcoin::util::amount::serde::as_sat")]
     pub collateral_amount: Amount,
-    collateral_inputs: Vec<Input>,
+    pub collateral_inputs: Vec<Input>,
     #[serde(with = "::elements::bitcoin::util::amount::serde::as_sat")]
     fee_sats_per_vbyte: Amount,
-    borrower_pk: PublicKey,
+    pub borrower_pk: PublicKey,
     /// Loan term in days
     pub term: u32,
-    borrower_address: Address,
-}
-
-impl From<LoanRequest> for baru::loan::LoanRequest {
-    fn from(loan_request: LoanRequest) -> Self {
-        baru::loan::LoanRequest::new(
-            loan_request.collateral_amount,
-            loan_request.collateral_inputs,
-            loan_request.fee_sats_per_vbyte,
-            loan_request.borrower_pk,
-            loan_request.borrower_address,
-        )
-    }
+    pub borrower_address: Address,
 }

extension/wallet/src/esplora.rs

@@ -2,14 +2,16 @@ use anyhow::{anyhow, bail, Context, Result};
 use async_trait::async_trait;
 use elements::{
     encode::{deserialize, serialize_hex},
-    Address, TxOut,
+    Address, BlockHash, TxOut,
 };
 use elements::{Transaction, Txid};
 use futures::{stream::FuturesUnordered, TryStreamExt};
 use reqwest::{StatusCode, Url};
 
 use crate::cache_storage::CacheStorage;
 use crate::ESPLORA_API_URL;
+use baru::client::GetTxOuts;
+use wasm_bindgen::UnwrapThrowExt;
 
 pub struct EsploraClient {
     base_url: Url,
@@ -97,9 +99,43 @@ impl EsploraClient {
     }
 }
 
+/// Represents a UTXO as it is modeled by esplora.
+///
+/// We ignore the commitments and asset IDs because we need to fetch the full transaction anyway.
+/// Hence, we don't even bother with deserializing it here.
+#[derive(serde::Deserialize, Debug, PartialEq, Clone, Copy)]
+pub struct Utxo {
+    pub txid: Txid,
+    pub vout: u32,
+    pub status: UtxoStatus,
+}
+
+impl From<Utxo> for baru::Utxo {
+    fn from(utxo: Utxo) -> Self {
+        baru::Utxo {
+            txid: utxo.txid,
+            vout: utxo.vout,
+            status: baru::UtxoStatus {
+                confirmed: utxo.status.confirmed,
+                block_height: utxo.status.block_height,
+                block_hash: utxo.status.block_hash,
+                block_time: utxo.status.block_time,
+            },
+        }
+    }
+}
+
+#[derive(serde::Deserialize, Debug, PartialEq, Clone, Copy)]
+pub struct UtxoStatus {
+    pub confirmed: bool,
+    pub block_height: Option<u64>,
+    pub block_hash: Option<BlockHash>,
+    pub block_time: Option<u64>,
+}
+
 #[async_trait]
 impl GetTxOuts for EsploraClient {
-    async fn get_txouts(&self, address: Address) -> Result<Vec<(Utxo, TxOut)>> {
+    async fn get_txouts(&self, address: Address) -> Result<Vec<(baru::Utxo, TxOut)>> {
         let base_url = self.base_url.clone();
         let utxos = fetch_utxos(base_url.clone(), address).await?;
 
@@ -110,8 +146,7 @@ impl GetTxOuts for EsploraClient {
                 async move {
                     let mut tx = fetch_transaction(base_url, utxo.txid).await?;
                     let txout = tx.output.remove(utxo.vout as usize);
-
-                    Result::<_, anyhow::Error>::Ok((utxo, txout))
+                    Result::<_, anyhow::Error>::Ok((utxo.into(), txout))
                 }
             })
             .collect::<FuturesUnordered<_>>()

extension/wallet/src/lib.rs

@@ -2,7 +2,7 @@ use baru::wallet::Chain;
 use baru::wallet::Wallet;
 use bip32::{Language, Mnemonic};
 use conquer_once::Lazy;
-use elements::{bitcoin::util::amount::Amount, Address, AddressParams, Txid};
+use elements::{bitcoin::util::amount::Amount, Address, AddressParams, AssetId, Txid};
 use futures::lock::Mutex;
 use js_sys::Promise;
 use reqwest::Url;
@@ -25,6 +25,7 @@ mod protocol;
 mod storage;
 mod wallet;
 
+use crate::wallet::bip39_seed_words_w;
 pub use protocol::*;
 
 static LOADED_WALLET: Lazy<Mutex<Option<Wallet>>> = Lazy::new(Mutex::default);
@@ -167,35 +168,6 @@ pub fn setup() {
     handler.forget();
 }
 
-/// Generates 24 random seed words in english  
-#[wasm_bindgen]
-pub fn bip39_seed_words() -> Result<JsValue, JsValue> {
-    let mnemonic = wallet::bip39_seed_words(Language::English);
-    let words = mnemonic.phrase();
-
-    Ok(JsValue::from_str(words))
-}
-
-/// Create a new wallet from the given seed words (mnemonic) with the given name and password.
-///
-/// Fails if the seed words are invalid or if the wallet with this name already exists.
-/// The created wallet will be automatically loaded.
-#[wasm_bindgen]
-pub async fn create_new_bip39_wallet(
-    name: String,
-    seed_words: String,
-    password: String,
-) -> Result<JsValue, JsValue> {
-    let mnemonic = Mnemonic::new(seed_words, Language::English)
-        .map_err(|e| JsValue::from_str(format!("Could not parse seed words: {:?}", e).as_str()))?;
-
-    map_err_from_anyhow!(
-        wallet::create_from_bip39(name, mnemonic, password, &LOADED_WALLET).await
-    )?;
-
-    Ok(JsValue::null())
-}
-
 /// Retrieve the latest block height from Esplora
 #[wasm_bindgen]
 pub async fn get_block_height() -> Result<JsValue, JsValue> {

extension/wallet/src/protocol/extract_loan.rs

@@ -90,19 +90,19 @@ async fn extract_loan_w(
     let loan_txid = borrower.loan_transaction().txid();
     let loan_details = LoanDetails::new(
         btc_asset_id,
-        borrower1.collateral_amount(),
+        borrower.collateral_amount(),
         collateral_balance,
         usdt_asset_id,
-        borrower1.principal_amount(),
+        borrower.principal_amount(),
         principal_balance,
-        *timelock,
+        *timelock as u64,
         loan_txid,
     );
 
     storage
         .set_item(
             "borrower_state",
-            serde_json::to_string(&(borrower1, loan_details.clone())).map_err(Error::Serialize)?,
+            serde_json::to_string(&(borrower, loan_details.clone())).map_err(Error::Serialize)?,
         )
         .map_err(Error::Save)?;
 

extension/wallet/src/protocol/make_create_swap_payload.rs

@@ -1,6 +1,7 @@
 use crate::esplora::EsploraClient;
 use crate::wallet::current;
 use crate::{BTC_ASSET_ID, ESPLORA_API_URL, LOADED_WALLET, USDT_ASSET_ID};
+use baru::avg_vbytes;
 use baru::wallet::Wallet;
 use elements::bitcoin::secp256k1::SecretKey;
 use elements::bitcoin::util::amount::Denomination;
@@ -72,91 +73,50 @@ async fn make_create_swap_payload(
     sell_asset: AssetId,
     fee_asset: AssetId,
 ) -> Result<CreateSwapPayload, Error> {
+    let (bobs_fee_rate, fee_offset) = if fee_asset == sell_asset {
+        // Bob currently hardcodes a fee-rate of 1 sat / vbyte, hence
+        // there is no need for us to perform fee estimation. Later
+        // on, both parties should probably agree on a block-target
+        // and use the same estimation service.
+        let bobs_fee_rate = Amount::ONE_SAT;
+        let fee_offset = calculate_fee_offset(bobs_fee_rate);
+
+        (bobs_fee_rate.as_sat() as f32, fee_offset)
+    } else {
+        (0.0, Amount::ZERO)
+    };
+
     let client = {
         let guard = ESPLORA_API_URL.lock().expect_throw("can get lock");
         EsploraClient::new(guard.clone())
     };
 
-    let (utxos, secret_key, address, blinding_key) = {
+    let (outputs, secret_key, address, blinding_key) = {
         let mut wallet = current(&wallet_name, &LOADED_WALLET)
             .await
             .map_err(Error::LoadWallet)?;
         wallet.sync(&client).await.map_err(Error::SyncWallet)?;
+        let outputs = wallet
+            .coin_selection(sell_amount, sell_asset, bobs_fee_rate, fee_offset)
+            .map_err(Error::CoinSelection)?;
         (
-            wallet.utxos(),
+            outputs,
             wallet.secret_key(),
             wallet.address(),
             wallet.blinding_secret_key(),
         )
     };
 
-    let utxos = utxos
-        .into_iter()
-        .filter_map(|(utxo, txout)| {
-            let outpoint = OutPoint {
-                txid: utxo.txid,
-                vout: utxo.vout,
-            };
-
-            let unblinded_txout = match txout.unblind(SECP256K1, secret_key) {
-                Ok(txout) => txout,
-                Err(_) => {
-                    log::warn!("could not unblind utxo {}, ignoring", outpoint);
-                    return None;
-                }
-            };
-            let candidate_asset = unblinded_txout.asset;
-
-            if candidate_asset == sell_asset {
-                Some(coin_selection::Utxo {
-                    outpoint,
-                    value: unblinded_txout.value,
-                    script_pubkey: txout.script_pubkey,
-                    asset: candidate_asset,
-                })
-            } else {
-                log::debug!(
-                    "utxo {} with asset id {} is not the sell asset, ignoring",
-                    outpoint,
-                    candidate_asset
-                );
-                None
-            }
-        })
-        .collect::<Vec<_>>();
-
-    let (bobs_fee_rate, fee_offset) = if fee_asset == sell_asset {
-        // Bob currently hardcodes a fee-rate of 1 sat / vbyte, hence
-        // there is no need for us to perform fee estimation. Later
-        // on, both parties should probably agree on a block-target
-        // and use the same estimation service.
-        let bobs_fee_rate = Amount::from_sat(1);
-        let fee_offset = calculate_fee_offset(bobs_fee_rate);
-
-        (bobs_fee_rate, fee_offset)
-    } else {
-        (Amount::ZERO, Amount::ZERO)
-    };
-
-    let output = coin_select(
-        utxos,
-        sell_amount,
-        bobs_fee_rate.as_sat() as f32,
-        fee_offset,
-    )
-    .map_err(Error::CoinSelection)?;
-
     Ok(CreateSwapPayload {
         address,
-        alice_inputs: output
-            .coins
+        alice_inputs: outputs
             .into_iter()
             .map(|utxo| SwapUtxo {
-                outpoint: utxo.outpoint,
+                outpoint: utxo.txin,
                 blinding_key,
             })
             .collect(),
-        amount: output.target_amount,
+        amount: sell_amount,
     })
 }
 
@@ -167,7 +127,7 @@ pub enum Error {
     #[error("Could not sync waller: {0}")]
     SyncWallet(anyhow::Error),
     #[error("Coin selection: {0}")]
-    CoinSelection(coin_selection::Error),
+    CoinSelection(anyhow::Error),
 }
 /// Calculate the fee offset required for the coin selection algorithm.
 ///