feat(asb): Enhance history command with extra information

swap/src/bin/asb.rs

@@ -15,6 +15,8 @@
 use anyhow::{bail, Context, Result};
 use comfy_table::Table;
 use libp2p::Swarm;
+use rust_decimal::prelude::FromPrimitive;
+use rust_decimal::Decimal;
 use std::convert::TryInto;
 use std::env;
 use std::sync::Arc;
@@ -31,10 +33,13 @@ use swap::common::{self, get_logs, warn_if_outdated};
 use swap::database::{open_db, AccessMode};
 use swap::network::rendezvous::XmrBtcNamespace;
 use swap::network::swarm;
+use swap::protocol::alice::swap::is_complete;
 use swap::protocol::alice::{run, AliceState};
+use swap::protocol::{Database, State};
 use swap::seed::Seed;
 use swap::{bitcoin, kraken, monero};
 use tracing_subscriber::filter::LevelFilter;
+use uuid::Uuid;
 
 const DEFAULT_WALLET_NAME: &str = "asb-wallet";
 
@@ -230,17 +235,39 @@ pub async fn main() -> Result<()> {
         }
         Command::History => {
             let db = open_db(config.data.dir.join("sqlite"), AccessMode::ReadOnly, None).await?;
-
             let mut table = Table::new();
 
-            table.set_header(vec!["SWAP ID", "STATE"]);
-
-            for (swap_id, state) in db.all().await? {
-                let state: AliceState = state.try_into()?;
-                table.add_row(vec![swap_id.to_string(), state.to_string()]);
+            table.set_header(vec![
+                "Swap ID",
+                "Start Date",
+                "State",
+                "Bitcoin Lock TxId",
+                "BTC Amount",
+                "XMR Amount",
+                "Exchange Rate",
+                "Trading Partner Peer ID",
+                "Completed",
+            ]);
+
+            let all_swaps = db.all().await?;
+            for (swap_id, state) in all_swaps {
+                match SwapDetails::from_db_state(swap_id.clone(), state, &db).await {
+                    Ok(details) => {
+                        if json {
+                            details.log_info();
+                        } else {
+                            table.add_row(details.to_table_row());
+                        }
+                    }
+                    Err(e) => {
+                        tracing::error!(swap_id = %swap_id, error = %e, "Failed to get swap details");
+                    }
+                }
             }
 
-            println!("{}", table);
+            if !json {
+                println!("{}", table);
+            }
         }
         Command::Config => {
             let config_json = serde_json::to_string_pretty(&config)?;
@@ -393,3 +420,96 @@ async fn init_monero_wallet(
 
     Ok(wallet)
 }
+
+/// This struct is used to extract swap details from the database and print them in a table format
+#[derive(Debug)]
+struct SwapDetails {
+    swap_id: String,
+    start_date: String,
+    state: String,
+    btc_lock_txid: String,
+    btc_amount: String,
+    xmr_amount: String,
+    exchange_rate: String,
+    peer_id: String,
+    completed: bool,
+}
+
+impl SwapDetails {
+    async fn from_db_state(
+        swap_id: Uuid,
+        state: State,
+        db: &Arc<dyn Database + Send + Sync>,
+    ) -> Result<Self> {
+        let latest_state: AliceState = state.try_into()?;
+        let completed = is_complete(&latest_state);
+
+        let all_states = db.get_states(swap_id.clone()).await?;
+        let state3 = all_states
+            .iter()
+            .find_map(|s| match s {
+                State::Alice(AliceState::BtcLockTransactionSeen { state3 }) => Some(state3),
+                _ => None,
+            })
+            .context("Failed to get \"BtcLockTransactionSeen\" state")?;
+
+        let exchange_rate = Self::calculate_exchange_rate(state3.btc, state3.xmr)?;
+        let start_date = db.get_swap_start_date(swap_id.clone()).await?;
+        let btc_lock_txid = state3.tx_lock.txid();
+        let peer_id = db.get_peer_id(swap_id.clone()).await?;
+
+        Ok(Self {
+            swap_id: swap_id.to_string(),
+            start_date: start_date.to_string(),
+            state: latest_state.to_string(),
+            btc_lock_txid: btc_lock_txid.to_string(),
+            btc_amount: state3.btc.to_string(),
+            xmr_amount: state3.xmr.to_string(),
+            exchange_rate,
+            peer_id: peer_id.to_string(),
+            completed,
+        })
+    }
+
+    fn calculate_exchange_rate(btc: bitcoin::Amount, xmr: monero::Amount) -> Result<String> {
+        let btc_decimal = Decimal::from_f64(btc.to_btc())
+            .ok_or_else(|| anyhow::anyhow!("Failed to convert BTC amount to Decimal"))?;
+        let xmr_decimal = Decimal::from_f64(xmr.as_xmr())
+            .ok_or_else(|| anyhow::anyhow!("Failed to convert XMR amount to Decimal"))?;
+
+        let rate = btc_decimal
+            .checked_div(xmr_decimal)
+            .ok_or_else(|| anyhow::anyhow!("Division by zero or overflow"))?;
+
+        Ok(format!("{} XMR/BTC", rate.round_dp(8)))
+    }
+
+    fn to_table_row(&self) -> Vec<String> {
+        vec![
+            self.swap_id.clone(),
+            self.start_date.clone(),
+            self.state.clone(),
+            self.btc_lock_txid.clone(),
+            self.btc_amount.clone(),
+            self.xmr_amount.clone(),
+            self.exchange_rate.clone(),
+            self.peer_id.clone(),
+            self.completed.to_string(),
+        ]
+    }
+
+    fn log_info(&self) {
+        tracing::info!(
+            swap_id = %self.swap_id,
+            swap_start_date = %self.start_date,
+            latest_state = %self.state,
+            btc_lock_txid = %self.btc_lock_txid,
+            btc_amount = %self.btc_amount,
+            xmr_amount = %self.xmr_amount,
+            exchange_rate = %self.exchange_rate,
+            trading_partner_peer_id = %self.peer_id,
+            completed = self.completed,
+            "Found swap in database"
+        );
+    }
+}

swap/src/monero.rs

@@ -109,6 +109,11 @@ impl Amount {
         self.0
     }
 
+    /// Return Monero Amount as XMR.
+    pub fn as_xmr(&self) -> f64 {
+        self.0 as f64 / PICONERO_OFFSET as f64
+    }
+
     /// Calculate the maximum amount of Bitcoin that can be bought at a given
     /// asking price for this amount of Monero including the median fee.
     pub fn max_bitcoin_for_price(&self, ask_price: bitcoin::Amount) -> Option<bitcoin::Amount> {

swap/src/protocol/alice/state.rs

@@ -384,8 +384,8 @@ pub struct State3 {
     S_b_bitcoin: bitcoin::PublicKey,
     pub v: monero::PrivateViewKey,
     #[serde(with = "::bitcoin::util::amount::serde::as_sat")]
-    btc: bitcoin::Amount,
-    xmr: monero::Amount,
+    pub btc: bitcoin::Amount,
+    pub xmr: monero::Amount,
     pub cancel_timelock: CancelTimelock,
     pub punish_timelock: PunishTimelock,
     refund_address: bitcoin::Address,

swap/src/protocol/alice/swap.rs

@@ -453,7 +453,7 @@ where
     })
 }
 
-pub(crate) fn is_complete(state: &AliceState) -> bool {
+pub fn is_complete(state: &AliceState) -> bool {
     matches!(
         state,
         AliceState::XmrRefunded