liquid: fetch asset metadata from esplora

Signed-off-by: lvaccaro <[email protected]>

bitcoin/src/lib.rs

@@ -113,7 +113,7 @@ impl BTCWallet {
         &mut self,
         addr: &str,
         from_height: Option<usize>,
-    ) -> Result<HashMap<String, u64>, bdk::Error> {
+    ) -> Result<HashMap<String, String>, bdk::Error> {
         let list = self.check_address(addr, from_height)?;
         let mut balances = HashMap::new();
 
@@ -127,7 +127,7 @@ impl BTCWallet {
                 }
             }
         };
-        balances.insert("btc".to_string(), amount);
+        balances.insert("btc".to_string(), amount.to_string());
         Ok(balances)
     }
 

lightning/src/lib.rs

@@ -229,7 +229,7 @@ impl ClightningWallet {
         &mut self,
         addr: &str,
         _from_height: Option<usize>,
-    ) -> Result<HashMap<String, u64>, Error> {
+    ) -> Result<HashMap<String, String>, Error> {
         let mut balances = HashMap::new();
         let decoded = self.decode(addr).unwrap();
         let payment_hash = decoded["result"]["payment_hash"].as_str().unwrap();
@@ -246,7 +246,7 @@ impl ClightningWallet {
             }
             _ => 0,
         };
-        balances.insert(addr.to_string(), msat);
+        balances.insert(addr.to_string(), msat.to_string());
         Ok(balances)
     }
 

liquid/Cargo.toml

@@ -1,12 +1,17 @@
 [package]
 name = "btctipserver-liquid"
 version = "0.1.1-dev"
+edition = "2021"
 
 [dependencies]
 edk = { git = "https://github.com/lvaccaro/edk.git" }
 dirs-next = "2.0.0"
 structopt = "0.3"
 hex = "0.4"
+reqwest = { version = "0.11.22", features = ["blocking", "json"] }
+serde = "1.0.114"
+serde_json = "1.0"
+serde_derive = "1.0.114"
 
 [features]
-electrum = ["edk/electrum"]
+electrum = ["edk/electrum"]

liquid/src/esplora.rs

@@ -0,0 +1,37 @@
+use edk::bdk::Error;
+use serde_derive::Deserialize;
+use std::collections::HashMap;
+
+pub fn gen_err() -> Error {
+    Error::Generic(format!("oh no!"))
+}
+
+#[derive(Deserialize, Clone, Debug)]
+pub struct Asset {
+    pub asset_id: String,
+    pub precision: u8,
+    pub name: String,
+    pub ticker: String,
+}
+
+pub struct EsploraRepository {
+    pub assets: HashMap<String, Asset>,
+}
+
+impl EsploraRepository {
+    pub fn get(&mut self, asset_id: String) -> Result<Asset, Error> {
+        match self.assets.get(&asset_id).as_ref() {
+            Some(&asset) => Ok(asset.clone()),
+            None => self.fetch(asset_id),
+        }
+    }
+
+    pub fn fetch(&mut self, asset_id: String) -> Result<Asset, Error> {
+        let url = format!("https://blockstream.info/liquid/api/asset/{}", asset_id);
+        let res = reqwest::blocking::get(url).map_err(|_| gen_err())?;
+        let asset: Asset = res.json().map_err(|_| gen_err())?;
+        println!("Asset: {:#?}", asset);
+        self.assets.insert(asset_id, asset.clone());
+        Ok(asset)
+    }
+}

liquid/src/lib.rs

@@ -1,24 +1,29 @@
 pub mod config;
+pub mod esplora;
 
 pub extern crate edk;
+extern crate reqwest;
 extern crate structopt;
 
 use crate::config::LiquidOpts;
 use edk::bdk::electrum_client::Client;
 use edk::bdk::Error;
 use std::collections::HashMap;
+use std::ops::Div;
 use std::str::FromStr;
 
 use edk::bdk::sled::{self, Tree};
 use edk::miniscript::elements::secp256k1_zkp;
 use edk::miniscript::elements::slip77::MasterBlindingKey;
 use edk::miniscript::elements::Address;
 use edk::miniscript::{Descriptor, DescriptorPublicKey};
+use esplora::EsploraRepository;
 use std::fs;
 use std::path::PathBuf;
 
 pub struct LiquidWallet {
     wallet: edk::Wallet<Tree>,
+    esplora: EsploraRepository,
 }
 
 pub fn gen_err() -> Error {
@@ -63,7 +68,12 @@ impl LiquidWallet {
             opts.network(),
         )
         .unwrap();
-        Ok(LiquidWallet { wallet })
+        Ok(LiquidWallet {
+            wallet,
+            esplora: EsploraRepository {
+                assets: HashMap::new(),
+            },
+        })
     }
 }
 
@@ -82,7 +92,7 @@ impl LiquidWallet {
         &mut self,
         addr: &str,
         _from_height: Option<usize>,
-    ) -> Result<HashMap<String, u64>, Error> {
+    ) -> Result<HashMap<String, String>, Error> {
         let addr = Address::from_str(addr).map_err(|_| gen_err())?;
         let mut balances = HashMap::new();
         for unblind in self
@@ -92,9 +102,23 @@ impl LiquidWallet {
             .unblinds
         {
             let tx_out = unblind.1;
-            *balances.entry(tx_out.asset.to_string()).or_insert(0) += tx_out.value;
+            *balances.entry(tx_out.asset).or_insert(0) += tx_out.value;
         }
-        Ok(balances)
+
+        let res = balances
+            .into_iter()
+            .filter_map(|(key, value)| {
+                let asset_id = key.to_string();
+                match self.esplora.get(asset_id.clone()) {
+                    Ok(asset) => Some((
+                        format!("{} ({})", asset.name, asset_id),
+                        (value / 10_u64.pow(asset.precision.into())).to_string(),
+                    )),
+                    Err(_) => Some((key.to_string(), value.to_string())),
+                }
+            })
+            .collect();
+        Ok(res)
     }
 
     pub fn network(&mut self) -> Result<String, Error> {

server/src/server.rs

@@ -85,7 +85,6 @@ pub fn page(wallet: &mut Wallet, uri: &str) -> Result<String, Error> {
         .balance_address(&page.address, Option::from(0))
         .map_err(|_| gen_err())?
         .into_iter()
-        .filter(|(_, v)| *v > 0)
         .map(|(k, v)| (k.clone(), v.clone()))
         .map(|(k, v)| format!("{}: {}", k, v))
         .collect::<Vec<String>>()

server/src/wallet.rs

@@ -47,7 +47,7 @@ impl Wallet {
         &mut self,
         addr: &str,
         _from_height: Option<usize>,
-    ) -> Result<HashMap<String, u64>, Error> {
+    ) -> Result<HashMap<String, String>, Error> {
         match self {
             Wallet::BTCWallet(w) => w.balance_address(addr, _from_height).map_err(|_| gen_err()),
             Wallet::LiquidWallet(w) => w.balance_address(addr, _from_height).map_err(|_| gen_err()),