[blockchain] add the Esplora backend

src/blockchain/esplora.rs

@@ -0,0 +1,284 @@
+use std::collections::HashSet;
+
+#[allow(unused_imports)]
+use log::{debug, error, info, trace};
+
+use serde::Deserialize;
+
+use reqwest::blocking::Client;
+use reqwest::StatusCode;
+
+use bitcoin::consensus::{deserialize, serialize};
+use bitcoin::hashes::hex::ToHex;
+use bitcoin::hashes::{sha256, Hash};
+use bitcoin::{Script, Transaction, Txid};
+
+use self::utils::{ELSGetHistoryRes, ELSListUnspentRes, ElectrumLikeSync};
+use super::*;
+use crate::database::{BatchDatabase, DatabaseUtils};
+use crate::error::Error;
+
+#[derive(Debug)]
+pub struct UrlClient {
+    url: String,
+    client: Client,
+}
+
+#[derive(Debug)]
+pub struct EsploraBlockchain(Option<UrlClient>);
+
+impl std::convert::From<UrlClient> for EsploraBlockchain {
+    fn from(url_client: UrlClient) -> Self {
+        EsploraBlockchain(Some(url_client))
+    }
+}
+
+impl EsploraBlockchain {
+    pub fn new(base_url: &str) -> Self {
+        EsploraBlockchain(Some(UrlClient {
+            url: base_url.to_string(),
+            client: Client::new(),
+        }))
+    }
+}
+
+impl Blockchain for EsploraBlockchain {
+    fn offline() -> Self {
+        EsploraBlockchain(None)
+    }
+
+    fn is_online(&self) -> bool {
+        self.0.is_some()
+    }
+}
+
+impl OnlineBlockchain for EsploraBlockchain {
+    fn get_capabilities(&self) -> HashSet<Capability> {
+        vec![Capability::FullHistory, Capability::GetAnyTx]
+            .into_iter()
+            .collect()
+    }
+
+    fn setup<D: BatchDatabase + DatabaseUtils, P: Progress>(
+        &mut self,
+        stop_gap: Option<usize>,
+        database: &mut D,
+        progress_update: P,
+    ) -> Result<(), Error> {
+        self.0
+            .as_mut()
+            .ok_or(Error::OfflineClient)?
+            .electrum_like_setup(stop_gap, database, progress_update)
+    }
+
+    fn get_tx(&mut self, txid: &Txid) -> Result<Option<Transaction>, Error> {
+        Ok(self.0.as_mut().ok_or(Error::OfflineClient)?._get_tx(txid)?)
+    }
+
+    fn broadcast(&mut self, tx: &Transaction) -> Result<(), Error> {
+        Ok(self
+            .0
+            .as_mut()
+            .ok_or(Error::OfflineClient)?
+            ._broadcast(tx)?)
+    }
+
+    fn get_height(&mut self) -> Result<usize, Error> {
+        Ok(self.0.as_mut().ok_or(Error::OfflineClient)?._get_height()?)
+    }
+}
+
+impl UrlClient {
+    fn script_to_scripthash(script: &Script) -> String {
+        sha256::Hash::hash(script.as_bytes()).into_inner().to_hex()
+    }
+
+    fn _get_tx(&self, txid: &Txid) -> Result<Option<Transaction>, EsploraError> {
+        let resp = self
+            .client
+            .get(&format!("{}/api/tx/{}/raw", self.url, txid))
+            .send()?;
+
+        if let StatusCode::NOT_FOUND = resp.status() {
+            return Ok(None);
+        }
+
+        Ok(Some(deserialize(&resp.error_for_status()?.bytes()?)?))
+    }
+
+    fn _broadcast(&self, transaction: &Transaction) -> Result<(), EsploraError> {
+        self.client
+            .post(&format!("{}/api/tx", self.url))
+            .body(serialize(transaction).to_hex())
+            .send()?
+            .error_for_status()?;
+
+        Ok(())
+    }
+
+    fn _get_height(&self) -> Result<usize, EsploraError> {
+        Ok(self
+            .client
+            .get(&format!("{}/api/blocks/tip/height", self.url))
+            .send()?
+            .error_for_status()?
+            .text()?
+            .parse()?)
+    }
+
+    fn _script_get_history(&self, script: &Script) -> Result<Vec<ELSGetHistoryRes>, EsploraError> {
+        let mut result = Vec::new();
+        let scripthash = Self::script_to_scripthash(script);
+
+        // Add the unconfirmed transactions first
+        result.extend(
+            self.client
+                .get(&format!(
+                    "{}/api/scripthash/{}/txs/mempool",
+                    self.url, scripthash
+                ))
+                .send()?
+                .error_for_status()?
+                .json::<Vec<EsploraGetHistory>>()?
+                .into_iter()
+                .map(|x| ELSGetHistoryRes {
+                    tx_hash: x.txid,
+                    height: x.status.block_height.unwrap_or(0) as i32,
+                }),
+        );
+
+        debug!(
+            "Found {} mempool txs for {} - {:?}",
+            result.len(),
+            scripthash,
+            script
+        );
+
+        // Then go through all the pages of confirmed transactions
+        let mut last_txid = String::new();
+        loop {
+            let response = self
+                .client
+                .get(&format!(
+                    "{}/api/scripthash/{}/txs/chain/{}",
+                    self.url, scripthash, last_txid
+                ))
+                .send()?
+                .error_for_status()?
+                .json::<Vec<EsploraGetHistory>>()?;
+            let len = response.len();
+            if let Some(elem) = response.last() {
+                last_txid = elem.txid.to_hex();
+            }
+
+            debug!("... adding {} confirmed transactions", len);
+
+            result.extend(response.into_iter().map(|x| ELSGetHistoryRes {
+                tx_hash: x.txid,
+                height: x.status.block_height.unwrap_or(0) as i32,
+            }));
+
+            if len < 25 {
+                break;
+            }
+        }
+
+        Ok(result)
+    }
+
+    fn _script_list_unspent(
+        &self,
+        script: &Script,
+    ) -> Result<Vec<ELSListUnspentRes>, EsploraError> {
+        Ok(self
+            .client
+            .get(&format!(
+                "{}/api/scripthash/{}/utxo",
+                self.url,
+                Self::script_to_scripthash(script)
+            ))
+            .send()?
+            .error_for_status()?
+            .json::<Vec<EsploraListUnspent>>()?
+            .into_iter()
+            .map(|x| ELSListUnspentRes {
+                tx_hash: x.txid,
+                height: x.status.block_height.unwrap_or(0),
+                tx_pos: x.vout,
+            })
+            .collect())
+    }
+}
+
+impl ElectrumLikeSync for UrlClient {
+    fn els_batch_script_get_history<'s, I: IntoIterator<Item = &'s Script>>(
+        &mut self,
+        scripts: I,
+    ) -> Result<Vec<Vec<ELSGetHistoryRes>>, Error> {
+        Ok(scripts
+            .into_iter()
+            .map(|script| self._script_get_history(script))
+            .collect::<Result<Vec<_>, _>>()?)
+    }
+
+    fn els_batch_script_list_unspent<'s, I: IntoIterator<Item = &'s Script>>(
+        &mut self,
+        scripts: I,
+    ) -> Result<Vec<Vec<ELSListUnspentRes>>, Error> {
+        Ok(scripts
+            .into_iter()
+            .map(|script| self._script_list_unspent(script))
+            .collect::<Result<Vec<_>, _>>()?)
+    }
+
+    fn els_transaction_get(&mut self, txid: &Txid) -> Result<Transaction, Error> {
+        Ok(self
+            ._get_tx(txid)?
+            .ok_or_else(|| EsploraError::TransactionNotFound(*txid))?)
+    }
+}
+
+#[derive(Deserialize)]
+struct EsploraGetHistoryStatus {
+    block_height: Option<usize>,
+}
+
+#[derive(Deserialize)]
+struct EsploraGetHistory {
+    txid: Txid,
+    status: EsploraGetHistoryStatus,
+}
+
+#[derive(Deserialize)]
+struct EsploraListUnspent {
+    txid: Txid,
+    vout: usize,
+    status: EsploraGetHistoryStatus,
+}
+
+#[derive(Debug)]
+pub enum EsploraError {
+    Reqwest(reqwest::Error),
+    Parsing(std::num::ParseIntError),
+    BitcoinEncoding(bitcoin::consensus::encode::Error),
+
+    TransactionNotFound(Txid),
+}
+
+impl From<reqwest::Error> for EsploraError {
+    fn from(other: reqwest::Error) -> Self {
+        EsploraError::Reqwest(other)
+    }
+}
+
+impl From<std::num::ParseIntError> for EsploraError {
+    fn from(other: std::num::ParseIntError) -> Self {
+        EsploraError::Parsing(other)
+    }
+}
+
+impl From<bitcoin::consensus::encode::Error> for EsploraError {
+    fn from(other: bitcoin::consensus::encode::Error) -> Self {
+        EsploraError::BitcoinEncoding(other)
+    }
+}