feat: unify bitcoin core API clients

Here we unify the REST and RPC API clients
primarily to reduce code duplication.

Author: enigbe

src/chain/bitcoind/common.rs

@@ -0,0 +1,267 @@
+use crate::types::{ChainMonitor, ChannelManager, Sweeper, Wallet};
+
+use bitcoin::{transaction::Txid, Transaction};
+use bitcoin::{BlockHash, FeeRate};
+use lightning::chain::Listen;
+use lightning_block_sync::http::{HttpEndpoint, JsonResponse};
+use lightning_block_sync::poll::ValidatedBlockHeader;
+use lightning_block_sync::Cache;
+
+use base64::{prelude::BASE64_STANDARD, Engine};
+use serde::Serialize;
+
+use std::collections::{HashMap, VecDeque};
+use std::sync::Arc;
+
+#[derive(Debug, Clone)]
+pub(crate) struct MempoolEntry {
+	/// The transaction id
+	pub txid: Txid,
+	/// Local time transaction entered pool in seconds since 1 Jan 1970 GMT
+	pub time: u64,
+	/// Block height when transaction entered pool
+	pub height: u32,
+}
+
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "UPPERCASE")]
+pub(crate) enum FeeRateEstimationMode {
+	Economical,
+	Conservative,
+}
+
+pub(crate) struct FeeResponse(pub FeeRate);
+
+impl TryInto<FeeResponse> for JsonResponse {
+	type Error = std::io::Error;
+	fn try_into(self) -> std::io::Result<FeeResponse> {
+		if !self.0["errors"].is_null() {
+			return Err(std::io::Error::new(
+				std::io::ErrorKind::Other,
+				self.0["errors"].to_string(),
+			));
+		}
+		let fee_rate_btc_per_kvbyte = self.0["feerate"]
+			.as_f64()
+			.ok_or(std::io::Error::new(std::io::ErrorKind::Other, "Failed to parse fee rate"))?;
+		// Bitcoin Core gives us a feerate in BTC/KvB.
+		// Thus, we multiply by 25_000_000 (10^8 / 4) to get satoshis/kwu.
+		let fee_rate = {
+			let fee_rate_sat_per_kwu = (fee_rate_btc_per_kvbyte * 25_000_000.0).round() as u64;
+			FeeRate::from_sat_per_kwu(fee_rate_sat_per_kwu)
+		};
+		Ok(FeeResponse(fee_rate))
+	}
+}
+
+pub(crate) struct MempoolMinFeeResponse(pub FeeRate);
+
+impl TryInto<MempoolMinFeeResponse> for JsonResponse {
+	type Error = std::io::Error;
+	fn try_into(self) -> std::io::Result<MempoolMinFeeResponse> {
+		let fee_rate_btc_per_kvbyte = self.0["mempoolminfee"]
+			.as_f64()
+			.ok_or(std::io::Error::new(std::io::ErrorKind::Other, "Failed to parse fee rate"))?;
+		// Bitcoin Core gives us a feerate in BTC/KvB.
+		// Thus, we multiply by 25_000_000 (10^8 / 4) to get satoshis/kwu.
+		let fee_rate = {
+			let fee_rate_sat_per_kwu = (fee_rate_btc_per_kvbyte * 25_000_000.0).round() as u64;
+			FeeRate::from_sat_per_kwu(fee_rate_sat_per_kwu)
+		};
+		Ok(MempoolMinFeeResponse(fee_rate))
+	}
+}
+
+pub(crate) struct GetRawTransactionResponse(pub Transaction);
+
+impl TryInto<GetRawTransactionResponse> for JsonResponse {
+	type Error = std::io::Error;
+	fn try_into(self) -> std::io::Result<GetRawTransactionResponse> {
+		let tx = self
+			.0
+			.as_str()
+			.ok_or(std::io::Error::new(
+				std::io::ErrorKind::Other,
+				"Failed to parse getrawtransaction response",
+			))
+			.and_then(|s| {
+				bitcoin::consensus::encode::deserialize_hex(s).map_err(|_| {
+					std::io::Error::new(
+						std::io::ErrorKind::Other,
+						"Failed to parse getrawtransaction response",
+					)
+				})
+			})?;
+
+		Ok(GetRawTransactionResponse(tx))
+	}
+}
+
+pub(crate) struct GetRawMempoolResponse(pub Vec<Txid>);
+
+impl TryInto<GetRawMempoolResponse> for JsonResponse {
+	type Error = std::io::Error;
+	fn try_into(self) -> std::io::Result<GetRawMempoolResponse> {
+		let res = self.0.as_array().ok_or(std::io::Error::new(
+			std::io::ErrorKind::Other,
+			"Failed to parse getrawmempool response",
+		))?;
+
+		let mut mempool_transactions = Vec::with_capacity(res.len());
+
+		for hex in res {
+			let txid = if let Some(hex_str) = hex.as_str() {
+				match bitcoin::consensus::encode::deserialize_hex(hex_str) {
+					Ok(txid) => txid,
+					Err(_) => {
+						return Err(std::io::Error::new(
+							std::io::ErrorKind::Other,
+							"Failed to parse getrawmempool response",
+						));
+					},
+				}
+			} else {
+				return Err(std::io::Error::new(
+					std::io::ErrorKind::Other,
+					"Failed to parse getrawmempool response",
+				));
+			};
+
+			mempool_transactions.push(txid);
+		}
+
+		Ok(GetRawMempoolResponse(mempool_transactions))
+	}
+}
+
+pub(crate) struct GetMempoolEntryResponse {
+	pub time: u64,
+	pub height: u32,
+}
+
+impl TryInto<GetMempoolEntryResponse> for JsonResponse {
+	type Error = std::io::Error;
+	fn try_into(self) -> std::io::Result<GetMempoolEntryResponse> {
+		let res = self.0.as_object().ok_or(std::io::Error::new(
+			std::io::ErrorKind::Other,
+			"Failed to parse getmempoolentry response",
+		))?;
+
+		let time = match res["time"].as_u64() {
+			Some(time) => time,
+			None => {
+				return Err(std::io::Error::new(
+					std::io::ErrorKind::Other,
+					"Failed to parse getmempoolentry response",
+				));
+			},
+		};
+
+		let height = match res["height"].as_u64().and_then(|h| h.try_into().ok()) {
+			Some(height) => height,
+			None => {
+				return Err(std::io::Error::new(
+					std::io::ErrorKind::Other,
+					"Failed to parse getmempoolentry response",
+				));
+			},
+		};
+
+		Ok(GetMempoolEntryResponse { time, height })
+	}
+}
+
+const MAX_HEADER_CACHE_ENTRIES: usize = 100;
+
+pub(crate) struct BoundedHeaderCache {
+	header_map: HashMap<BlockHash, ValidatedBlockHeader>,
+	recently_seen: VecDeque<BlockHash>,
+}
+
+impl BoundedHeaderCache {
+	pub(crate) fn new() -> Self {
+		let header_map = HashMap::new();
+		let recently_seen = VecDeque::new();
+		Self { header_map, recently_seen }
+	}
+}
+
+impl Cache for BoundedHeaderCache {
+	fn look_up(&self, block_hash: &BlockHash) -> Option<&ValidatedBlockHeader> {
+		self.header_map.get(block_hash)
+	}
+
+	fn block_connected(&mut self, block_hash: BlockHash, block_header: ValidatedBlockHeader) {
+		self.recently_seen.push_back(block_hash);
+		self.header_map.insert(block_hash, block_header);
+
+		if self.header_map.len() >= MAX_HEADER_CACHE_ENTRIES {
+			// Keep dropping old entries until we've actually removed a header entry.
+			while let Some(oldest_entry) = self.recently_seen.pop_front() {
+				if self.header_map.remove(&oldest_entry).is_some() {
+					break;
+				}
+			}
+		}
+	}
+
+	fn block_disconnected(&mut self, block_hash: &BlockHash) -> Option<ValidatedBlockHeader> {
+		self.recently_seen.retain(|e| e != block_hash);
+		self.header_map.remove(block_hash)
+	}
+}
+
+pub(crate) struct ChainListener {
+	pub(crate) onchain_wallet: Arc<Wallet>,
+	pub(crate) channel_manager: Arc<ChannelManager>,
+	pub(crate) chain_monitor: Arc<ChainMonitor>,
+	pub(crate) output_sweeper: Arc<Sweeper>,
+}
+
+impl Listen for ChainListener {
+	fn filtered_block_connected(
+		&self, header: &bitcoin::block::Header,
+		txdata: &lightning::chain::transaction::TransactionData, height: u32,
+	) {
+		self.onchain_wallet.filtered_block_connected(header, txdata, height);
+		self.channel_manager.filtered_block_connected(header, txdata, height);
+		self.chain_monitor.filtered_block_connected(header, txdata, height);
+		self.output_sweeper.filtered_block_connected(header, txdata, height);
+	}
+	fn block_connected(&self, block: &bitcoin::Block, height: u32) {
+		self.onchain_wallet.block_connected(block, height);
+		self.channel_manager.block_connected(block, height);
+		self.chain_monitor.block_connected(block, height);
+		self.output_sweeper.block_connected(block, height);
+	}
+
+	fn block_disconnected(&self, header: &bitcoin::block::Header, height: u32) {
+		self.onchain_wallet.block_disconnected(header, height);
+		self.channel_manager.block_disconnected(header, height);
+		self.chain_monitor.block_disconnected(header, height);
+		self.output_sweeper.block_disconnected(header, height);
+	}
+}
+
+pub(crate) fn rpc_credentials(rpc_user: String, rpc_password: String) -> String {
+	BASE64_STANDARD.encode(format!("{}:{}", rpc_user, rpc_password))
+}
+
+pub(crate) fn endpoint(host: String, port: u16) -> HttpEndpoint {
+	HttpEndpoint::for_host(host.clone()).with_port(port)
+}
+
+#[derive(Debug)]
+pub struct HttpError {
+	pub(crate) status_code: String,
+	pub(crate) contents: Vec<u8>,
+}
+
+impl std::error::Error for HttpError {}
+
+impl std::fmt::Display for HttpError {
+	fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+		let contents = String::from_utf8_lossy(&self.contents);
+		write!(f, "status_code: {}, contents: {}", self.status_code, contents)
+	}
+}