--- /dev/null
+use std::collections::{BTreeMap, VecDeque};
+#[cfg(test)]
+use std::fs::File;
+use std::io::{self, BufRead, BufReader, Read, Write};
+use std::net::{TcpStream, ToSocketAddrs};
+
+#[allow(unused_imports)]
+use log::{debug, error, info, trace};
+
+use bitcoin::blockdata::block;
+use bitcoin::blockdata::transaction::Transaction;
+use bitcoin::consensus::encode::{deserialize, serialize};
+use bitcoin::hashes::hex::{FromHex, ToHex};
+use bitcoin::{Script, Txid};
+
+#[cfg(feature = "ssl")]
+use openssl::ssl::{SslConnector, SslMethod, SslStream, SslVerifyMode};
+
+#[cfg(feature = "socks")]
+use socks::{Socks5Stream, ToTargetAddr};
+
+#[cfg(any(feature = "socks", feature = "proxy"))]
+use stream::ClonableStream;
+
+use batch::Batch;
+#[cfg(test)]
+use test_stream::TestStream;
+use types::*;
+
+macro_rules! impl_batch_call {
+ ( $self:expr, $data:expr, $call:ident ) => {{
+ let mut batch = Batch::default();
+ for i in $data {
+ batch.$call(i);
+ }
+
+ let resp = $self.batch_call(batch)?;
+ let mut answer = Vec::new();
+
+ for x in resp {
+ answer.push(serde_json::from_value(x)?);
+ }
+
+ Ok(answer)
+ }};
+}
+
+pub struct Client<S>
+where
+ S: Read + Write,
+{
+ stream: S,
+ buf_reader: BufReader<S>,
+
+ headers: VecDeque<HeaderNotification>,
+ script_notifications: BTreeMap<ScriptHash, VecDeque<ScriptStatus>>,
+
+ #[cfg(feature = "debug-calls")]
+ calls: usize,
+}
+
+impl Client<TcpStream> {
+ pub fn new<A: ToSocketAddrs>(socket_addr: A) -> io::Result<Self> {
+ let stream = TcpStream::connect(socket_addr)?;
+ let buf_reader = BufReader::new(stream.try_clone()?);
+
+ Ok(Self {
+ stream,
+ buf_reader,
+ headers: VecDeque::new(),
+ script_notifications: BTreeMap::new(),
+
+ #[cfg(feature = "debug-calls")]
+ calls: 0,
+ })
+ }
+}
+
+#[cfg(feature = "ssl")]
+impl Client<ClonableStream<SslStream<TcpStream>>> {
+ pub fn new_ssl<A: ToSocketAddrs>(socket_addr: A, domain: Option<&str>) -> Result<Self, Error> {
+ let mut builder =
+ SslConnector::builder(SslMethod::tls()).map_err(Error::InvalidSslMethod)?;
+ // TODO: support for certificate pinning
+ if domain.is_none() {
+ builder.set_verify(SslVerifyMode::NONE);
+ }
+ let connector = builder.build();
+
+ let stream = TcpStream::connect(socket_addr)?;
+ let stream = connector
+ .connect(domain.unwrap_or("not.validated"), stream)
+ .map_err(Error::SslHandshakeError)?;
+ let stream: ClonableStream<_> = stream.into();
+
+ let buf_reader = BufReader::new(stream.clone());
+
+ Ok(Self {
+ stream,
+ buf_reader,
+ headers: VecDeque::new(),
+ script_notifications: BTreeMap::new(),
+
+ #[cfg(feature = "debug-calls")]
+ calls: 0,
+ })
+ }
+}
+
+#[cfg(feature = "proxy")]
+impl Client<ClonableStream<Socks5Stream>> {
+ pub fn new_proxy<A: ToSocketAddrs, T: ToTargetAddr>(
+ target_addr: T,
+ proxy_addr: A,
+ ) -> Result<Self, Error> {
+ // TODO: support proxy credentials
+ let stream = Socks5Stream::connect(proxy_addr, target_addr)?;
+ let stream: ClonableStream<_> = stream.into();
+
+ let buf_reader = BufReader::new(stream.clone());
+
+ Ok(Self {
+ stream,
+ buf_reader,
+ headers: VecDeque::new(),
+ script_notifications: BTreeMap::new(),
+
+ #[cfg(feature = "debug-calls")]
+ calls: 0,
+ })
+ }
+}
+
+#[cfg(test)]
+impl Client<TestStream> {
+ pub fn new_test(file: File) -> Self {
+ let stream = TestStream::new_out();
+ let buf_reader = BufReader::new(TestStream::new_in(file));
+
+ Self {
+ stream,
+ buf_reader,
+ headers: VecDeque::new(),
+ script_notifications: BTreeMap::new(),
+ }
+ }
+}
+
+impl<S: Read + Write> Client<S> {
+ fn call(&mut self, req: Request) -> Result<serde_json::Value, Error> {
+ let mut raw = serde_json::to_vec(&req)?;
+ trace!("==> {}", String::from_utf8_lossy(&raw));
+
+ raw.extend_from_slice(b"\n");
+ self.stream.write_all(&raw)?;
+ self.stream.flush()?;
+
+ self.increment_calls();
+
+ let mut resp = loop {
+ let raw = self.recv()?;
+ let mut resp: serde_json::Value = serde_json::from_slice(&raw)?;
+
+ match resp["method"].take().as_str() {
+ Some(ref method) if method == &req.method => break resp,
+ Some(ref method) => self.handle_notification(method, resp["result"].take())?,
+ _ => break resp,
+ };
+ };
+
+ if let Some(err) = resp.get("error") {
+ return Err(Error::Protocol(err.clone()));
+ }
+
+ Ok(resp["result"].take())
+ }
+
+ pub fn batch_call(&mut self, batch: Batch) -> Result<Vec<serde_json::Value>, Error> {
+ let mut id_map = BTreeMap::new();
+ let mut raw = Vec::new();
+ let mut answer = Vec::new();
+
+ for (i, (method, params)) in batch.into_iter().enumerate() {
+ let req = Request::new_id(i, &method, params);
+
+ raw.append(&mut serde_json::to_vec(&req)?);
+ raw.extend_from_slice(b"\n");
+
+ id_map.insert(req.id, method);
+ }
+
+ trace!("==> {}", String::from_utf8_lossy(&raw));
+
+ self.stream.write_all(&raw)?;
+ self.stream.flush()?;
+
+ self.increment_calls();
+
+ while answer.len() < id_map.len() {
+ let raw = self.recv()?;
+ let mut resp: serde_json::Value = serde_json::from_slice(&raw)?;
+
+ let resp = match resp["id"].as_u64() {
+ Some(id) if id_map.contains_key(&(id as usize)) => resp,
+ _ => {
+ self.handle_notification(
+ resp["method"].take().as_str().unwrap_or(""),
+ resp["result"].take(),
+ )?;
+ continue;
+ }
+ };
+
+ if let Some(err) = resp.get("error") {
+ return Err(Error::Protocol(err.clone()));
+ }
+
+ answer.push(resp.clone());
+ }
+
+ answer.sort_by(|a, b| a["id"].as_u64().partial_cmp(&b["id"].as_u64()).unwrap());
+
+ let answer = answer.into_iter().map(|mut x| x["result"].take()).collect();
+ Ok(answer)
+ }
+
+ fn recv(&mut self) -> io::Result<Vec<u8>> {
+ let mut resp = String::new();
+ self.buf_reader.read_line(&mut resp)?;
+
+ trace!("<== {}", resp);
+
+ Ok(resp.as_bytes().to_vec())
+ }
+
+ fn handle_notification(
+ &mut self,
+ method: &str,
+ result: serde_json::Value,
+ ) -> Result<(), Error> {
+ match method {
+ "blockchain.headers.subscribe" => {
+ self.headers.push_back(serde_json::from_value(result)?)
+ }
+ "blockchain.scripthash.subscribe" => {
+ let unserialized: ScriptNotification = serde_json::from_value(result)?;
+
+ let queue = self
+ .script_notifications
+ .get_mut(&unserialized.scripthash)
+ .ok_or_else(|| Error::NotSubscribed(unserialized.scripthash))?;
+
+ queue.push_back(unserialized.status);
+ }
+ _ => info!("received unknown notification for method `{}`", method),
+ }
+
+ Ok(())
+ }
+
+ pub fn poll(&mut self) -> Result<(), Error> {
+ // try to pull data from the stream
+ self.buf_reader.fill_buf()?;
+
+ while !self.buf_reader.buffer().is_empty() {
+ let raw = self.recv()?;
+ let mut resp: serde_json::Value = serde_json::from_slice(&raw)?;
+
+ match resp["method"].take().as_str() {
+ Some(ref method) => self.handle_notification(method, resp["params"].take())?,
+ _ => continue,
+ }
+ }
+
+ Ok(())
+ }
+
+ pub fn block_headers_subscribe(&mut self) -> Result<HeaderNotification, Error> {
+ let req = Request::new("blockchain.headers.subscribe", vec![]);
+ let value = self.call(req)?;
+
+ Ok(serde_json::from_value(value)?)
+ }
+
+ pub fn block_headers_poll(&mut self) -> Result<Option<HeaderNotification>, Error> {
+ self.poll()?;
+
+ Ok(self.headers.pop_front())
+ }
+
+ pub fn block_header(&mut self, height: usize) -> Result<block::BlockHeader, Error> {
+ let req = Request::new("blockchain.block.header", vec![Param::Usize(height)]);
+ let result = self.call(req)?;
+
+ Ok(deserialize(&Vec::<u8>::from_hex(
+ result
+ .as_str()
+ .ok_or_else(|| Error::InvalidResponse(result.clone()))?,
+ )?)?)
+ }
+
+ pub fn block_headers(
+ &mut self,
+ start_height: usize,
+ count: usize,
+ ) -> Result<GetHeadersRes, Error> {
+ let req = Request::new(
+ "blockchain.block.headers",
+ vec![Param::Usize(start_height), Param::Usize(count)],
+ );
+ let result = self.call(req)?;
+
+ let mut deserialized: GetHeadersRes = serde_json::from_value(result)?;
+ for i in 0..deserialized.count {
+ let (start, end) = (i * 80, (i + 1) * 80);
+ deserialized
+ .headers
+ .push(deserialize(&deserialized.raw_headers[start..end])?);
+ }
+ deserialized.raw_headers.clear();
+
+ Ok(deserialized)
+ }
+
+ pub fn estimate_fee(&mut self, number: usize) -> Result<f64, Error> {
+ let req = Request::new("blockchain.estimatefee", vec![Param::Usize(number)]);
+ let result = self.call(req)?;
+
+ result
+ .as_f64()
+ .ok_or_else(|| Error::InvalidResponse(result.clone()))
+ }
+
+ pub fn relay_fee(&mut self) -> Result<f64, Error> {
+ let req = Request::new("blockchain.relayfee", vec![]);
+ let result = self.call(req)?;
+
+ result
+ .as_f64()
+ .ok_or_else(|| Error::InvalidResponse(result.clone()))
+ }
+
+ pub fn script_subscribe(&mut self, script: &Script) -> Result<ScriptStatus, Error> {
+ let script_hash = script.to_electrum_scripthash();
+
+ if self.script_notifications.contains_key(&script_hash) {
+ return Err(Error::AlreadySubscribed(script_hash));
+ }
+
+ self.script_notifications
+ .insert(script_hash.clone(), VecDeque::new());
+
+ let req = Request::new(
+ "blockchain.scripthash.subscribe",
+ vec![Param::String(script_hash.to_hex())],
+ );
+ let value = self.call(req)?;
+
+ Ok(serde_json::from_value(value)?)
+ }
+
+ pub fn script_unsubscribe(&mut self, script: &Script) -> Result<bool, Error> {
+ let script_hash = script.to_electrum_scripthash();
+
+ if !self.script_notifications.contains_key(&script_hash) {
+ return Err(Error::NotSubscribed(script_hash));
+ }
+
+ let req = Request::new(
+ "blockchain.scripthash.unsubscribe",
+ vec![Param::String(script_hash.to_hex())],
+ );
+ let value = self.call(req)?;
+ let answer = serde_json::from_value(value)?;
+
+ self.script_notifications.remove(&script_hash);
+
+ Ok(answer)
+ }
+
+ pub fn script_poll(&mut self, script: &Script) -> Result<Option<ScriptStatus>, Error> {
+ self.poll()?;
+
+ let script_hash = script.to_electrum_scripthash();
+
+ match self.script_notifications.get_mut(&script_hash) {
+ None => return Err(Error::NotSubscribed(script_hash)),
+ Some(queue) => Ok(queue.pop_front()),
+ }
+ }
+
+ pub fn script_get_balance(&mut self, script: &Script) -> Result<GetBalanceRes, Error> {
+ let params = vec![Param::String(script.to_electrum_scripthash().to_hex())];
+ let req = Request::new("blockchain.scripthash.get_balance", params);
+ let result = self.call(req)?;
+
+ Ok(serde_json::from_value(result)?)
+ }
+ pub fn batch_script_get_balance(
+ &mut self,
+ scripts: Vec<&Script>,
+ ) -> Result<Vec<GetBalanceRes>, Error> {
+ impl_batch_call!(self, scripts, script_get_balance)
+ }
+
+ pub fn script_get_history(&mut self, script: &Script) -> Result<Vec<GetHistoryRes>, Error> {
+ let params = vec![Param::String(script.to_electrum_scripthash().to_hex())];
+ let req = Request::new("blockchain.scripthash.get_history", params);
+ let result = self.call(req)?;
+
+ Ok(serde_json::from_value(result)?)
+ }
+ pub fn batch_script_get_history(
+ &mut self,
+ scripts: Vec<&Script>,
+ ) -> Result<Vec<Vec<GetHistoryRes>>, Error> {
+ impl_batch_call!(self, scripts, script_get_history)
+ }
+
+ pub fn script_list_unspent(&mut self, script: &Script) -> Result<Vec<ListUnspentRes>, Error> {
+ let params = vec![Param::String(script.to_electrum_scripthash().to_hex())];
+ let req = Request::new("blockchain.scripthash.listunspent", params);
+ let result = self.call(req)?;
+
+ Ok(serde_json::from_value(result)?)
+ }
+ pub fn batch_script_list_unspent(
+ &mut self,
+ scripts: Vec<&Script>,
+ ) -> Result<Vec<Vec<ListUnspentRes>>, Error> {
+ impl_batch_call!(self, scripts, script_list_unspent)
+ }
+
+ pub fn transaction_get(&mut self, tx_hash: &Txid) -> Result<Transaction, Error> {
+ let params = vec![Param::String(tx_hash.to_hex())];
+ let req = Request::new("blockchain.transaction.get", params);
+ let result = self.call(req)?;
+
+ Ok(deserialize(&Vec::<u8>::from_hex(
+ result
+ .as_str()
+ .ok_or_else(|| Error::InvalidResponse(result.clone()))?,
+ )?)?)
+ }
+ pub fn batch_transaction_get(
+ &mut self,
+ tx_hashes: Vec<&Txid>,
+ ) -> Result<Vec<Transaction>, Error> {
+ impl_batch_call!(self, tx_hashes, transaction_get)
+ }
+
+ pub fn transaction_broadcast(&mut self, tx: &Transaction) -> Result<Txid, Error> {
+ let buffer: Vec<u8> = serialize(tx);
+ let params = vec![Param::String(buffer.to_hex())];
+ let req = Request::new("blockchain.transaction.broadcast", params);
+ let result = self.call(req)?;
+
+ Ok(serde_json::from_value(result)?)
+ }
+
+ pub fn transaction_get_merkle(
+ &mut self,
+ txid: &Txid,
+ height: usize,
+ ) -> Result<GetMerkleRes, Error> {
+ let params = vec![Param::String(txid.to_hex()), Param::Usize(height)];
+ let req = Request::new("blockchain.transaction.get_merkle", params);
+ let result = self.call(req)?;
+
+ Ok(serde_json::from_value(result)?)
+ }
+
+ pub fn server_features(&mut self) -> Result<ServerFeaturesRes, Error> {
+ let req = Request::new("server.features", vec![]);
+ let result = self.call(req)?;
+
+ Ok(serde_json::from_value(result)?)
+ }
+
+ #[cfg(feature = "debug-calls")]
+ pub fn calls_made(&self) -> u32 {
+ self.calls
+ }
+
+ #[inline]
+ #[cfg(feature = "debug-calls")]
+ pub fn increment_calls(&mut self) {
+ self.calls += 1;
+ }
+
+ #[inline]
+ #[cfg(not(feature = "debug-calls"))]
+ pub fn increment_calls(&self) {}
+}
+
+#[cfg(test)]
+mod test {
+ use std::fs::File;
+ use std::io::Read;
+
+ use client::Client;
+
+ macro_rules! impl_test_prelude {
+ ( $testcase:expr ) => {{
+ let data_in = File::open(format!("./test_data/{}.in", $testcase)).unwrap();
+ Client::new_test(data_in)
+ }};
+ }
+
+ macro_rules! impl_test_conclusion {
+ ( $testcase:expr, $stream:expr ) => {
+ let mut data_out = File::open(format!("./test_data/{}.out", $testcase)).unwrap();
+ let mut buffer = Vec::new();
+ data_out.read_to_end(&mut buffer).unwrap();
+ let stream_buffer: Vec<u8> = $stream.into();
+
+ assert_eq!(
+ stream_buffer,
+ buffer,
+ "Expecting `{}`, got `{}`",
+ String::from_utf8_lossy(&buffer.to_vec()),
+ String::from_utf8_lossy(&stream_buffer)
+ );
+ };
+ }
+
+ #[test]
+ fn test_server_features_simple() {
+ let test_case = "server_features_simple";
+ let mut client = impl_test_prelude!(test_case);
+
+ let resp = client.server_features().unwrap();
+ assert_eq!(resp.server_version, "ElectrumX 1.0.17");
+ assert_eq!(
+ resp.genesis_hash,
+ [
+ 0x00, 0x00, 0x00, 0x00, 0x09, 0x33, 0xEA, 0x01, 0xAD, 0x0E, 0xE9, 0x84, 0x20, 0x97,
+ 0x79, 0xBA, 0xAE, 0xC3, 0xCE, 0xD9, 0x0F, 0xA3, 0xF4, 0x08, 0x71, 0x95, 0x26, 0xF8,
+ 0xD7, 0x7F, 0x49, 0x43
+ ]
+ );
+ assert_eq!(resp.protocol_min, "1.0");
+ assert_eq!(resp.protocol_max, "1.0");
+ assert_eq!(resp.hash_function, Some("sha256".into()));
+ assert_eq!(resp.pruning, None);
+
+ impl_test_conclusion!(test_case, client.stream);
+ }
+ #[test]
+ fn test_relay_fee() {
+ let test_case = "relay_fee";
+ let mut client = impl_test_prelude!(test_case);
+
+ let resp = client.relay_fee().unwrap();
+ assert_eq!(resp, 123.4);
+
+ impl_test_conclusion!(test_case, client.stream);
+ }
+
+ #[test]
+ fn test_estimate_fee() {
+ let test_case = "estimate_fee";
+ let mut client = impl_test_prelude!(test_case);
+
+ let resp = client.estimate_fee(10).unwrap();
+ assert_eq!(resp, 10.0);
+
+ impl_test_conclusion!(test_case, client.stream);
+ }
+
+ #[test]
+ fn test_block_header() {
+ let test_case = "block_header";
+ let mut client = impl_test_prelude!(test_case);
+
+ let resp = client.block_header(500).unwrap();
+ assert_eq!(resp.version, 536870912);
+ assert_eq!(resp.time, 1578166214);
+ assert_eq!(resp.nonce, 0);
+
+ impl_test_conclusion!(test_case, client.stream);
+ }
+
+ #[test]
+ fn test_block_headers() {
+ let test_case = "block_headers";
+ let mut client = impl_test_prelude!(test_case);
+
+ let resp = client.block_headers(100, 4).unwrap();
+ assert_eq!(resp.count, 4);
+ assert_eq!(resp.max, 2016);
+ assert_eq!(resp.headers.len(), 4);
+
+ assert_eq!(resp.headers[0].time, 1563694949);
+
+ impl_test_conclusion!(test_case, client.stream);
+ }
+
+ #[test]
+ fn test_script_get_balance() {
+ use std::str::FromStr;
+
+ let test_case = "script_get_balance";
+ let mut client = impl_test_prelude!(test_case);
+
+ let addr = bitcoin::Address::from_str("2N1xJCxBUXTDs6y8Sydz3axhAiXrrQwcosi").unwrap();
+ let resp = client.script_get_balance(&addr.script_pubkey()).unwrap();
+ assert_eq!(resp.confirmed, 0);
+ assert_eq!(resp.unconfirmed, 130000000);
+
+ impl_test_conclusion!(test_case, client.stream);
+ }
+
+ #[test]
+ fn test_script_get_history() {
+ use std::str::FromStr;
+
+ use bitcoin::hashes::hex::FromHex;
+ use bitcoin::Txid;
+
+ let test_case = "script_get_history";
+ let mut client = impl_test_prelude!(test_case);
+
+ let addr = bitcoin::Address::from_str("2N1xJCxBUXTDs6y8Sydz3axhAiXrrQwcosi").unwrap();
+ let resp = client.script_get_history(&addr.script_pubkey()).unwrap();
+ assert_eq!(resp.len(), 2);
+ assert_eq!(
+ resp[0].tx_hash,
+ Txid::from_hex("a1aa2b52fb79641f918d44a27f51781c3c0c49f7ee0e4b14dbb37c722853f046")
+ .unwrap()
+ );
+
+ impl_test_conclusion!(test_case, client.stream);
+ }
+
+ #[test]
+ fn test_script_list_unspent() {
+ use std::str::FromStr;
+
+ use bitcoin::hashes::hex::FromHex;
+ use bitcoin::Txid;
+
+ let test_case = "script_list_unspent";
+ let mut client = impl_test_prelude!(test_case);
+
+ let addr = bitcoin::Address::from_str("2N1xJCxBUXTDs6y8Sydz3axhAiXrrQwcosi").unwrap();
+ let resp = client.script_list_unspent(&addr.script_pubkey()).unwrap();
+ assert_eq!(resp.len(), 2);
+ assert_eq!(resp[0].value, 30000000);
+ assert_eq!(resp[0].height, 0);
+ assert_eq!(resp[0].tx_pos, 1);
+ assert_eq!(
+ resp[0].tx_hash,
+ Txid::from_hex("a1aa2b52fb79641f918d44a27f51781c3c0c49f7ee0e4b14dbb37c722853f046")
+ .unwrap()
+ );
+
+ impl_test_conclusion!(test_case, client.stream);
+ }
+
+ #[test]
+ fn test_batch_script_list_unspent() {
+ use std::str::FromStr;
+
+ let test_case = "batch_script_list_unspent";
+ let mut client = impl_test_prelude!(test_case);
+
+ let script_1 = bitcoin::Address::from_str("2N1xJCxBUXTDs6y8Sydz3axhAiXrrQwcosi")
+ .unwrap()
+ .script_pubkey();
+ let script_2 = bitcoin::Address::from_str("2MyEi7dbTfQxo1M4hJaAzA2tgEJFQhYv5Au")
+ .unwrap()
+ .script_pubkey();
+
+ let resp = client
+ .batch_script_list_unspent(vec![&script_1, &script_2])
+ .unwrap();
+ assert_eq!(resp.len(), 2);
+ assert_eq!(resp[0].len(), 2);
+ assert_eq!(resp[1].len(), 1);
+
+ impl_test_conclusion!(test_case, client.stream);
+ }
+
+ #[test]
+ fn test_transaction_get() {
+ use bitcoin::hashes::hex::FromHex;
+ use bitcoin::Txid;
+
+ let test_case = "transaction_get";
+ let mut client = impl_test_prelude!(test_case);
+
+ let resp = client
+ .transaction_get(
+ &Txid::from_hex("a1aa2b52fb79641f918d44a27f51781c3c0c49f7ee0e4b14dbb37c722853f046")
+ .unwrap(),
+ )
+ .unwrap();
+ assert_eq!(resp.version, 2);
+ assert_eq!(resp.lock_time, 1376);
+
+ impl_test_conclusion!(test_case, client.stream);
+ }
+
+ #[test]
+ fn test_transaction_broadcast() {
+ use bitcoin::consensus::deserialize;
+ use bitcoin::hashes::hex::FromHex;
+ use bitcoin::Txid;
+
+ let test_case = "transaction_broadcast";
+ let mut client = impl_test_prelude!(test_case);
+
+ let buf = Vec::<u8>::from_hex("02000000000101f6cd5873d669cc2de550453623d9d10ed5b5ba906d81160ee3ab853ebcfffa0c0100000000feffffff02e22f82000000000017a914e229870f3af1b1a3aefc3452a4d2939b443e6eba8780c3c9010000000017a9145f859501ff79211aeb972633b782743dd3b31dab8702473044022046ff3b0618107e08bd25fb753e31542b8c23575d7e9faf43dd17f59727cfb9c902200a4f3837105808d810de01fcd63fb18e66a69026090dc72b66840d41e55c6bf3012103e531113bbca998f8d164235e3395db336d3ba03552d1bfaa83fd7cffe6e5c6c960050000").unwrap();
+ let tx: bitcoin::Transaction = deserialize(&buf).unwrap();
+
+ let resp = client.transaction_broadcast(&tx).unwrap();
+ assert_eq!(
+ resp,
+ Txid::from_hex("a1aa2b52fb79641f918d44a27f51781c3c0c49f7ee0e4b14dbb37c722853f046")
+ .unwrap()
+ );
+
+ impl_test_conclusion!(test_case, client.stream);
+ }
+
+ #[test]
+ fn test_transaction_get_merkle() {
+ use bitcoin::hashes::hex::FromHex;
+ use bitcoin::Txid;
+
+ let test_case = "transaction_get_merkle";
+ let mut client = impl_test_prelude!(test_case);
+
+ let resp = client
+ .transaction_get_merkle(
+ &Txid::from_hex("2d64851151550e8c4d337f335ee28874401d55b358a66f1bafab2c3e9f48773d")
+ .unwrap(),
+ 1234,
+ )
+ .unwrap();
+ assert_eq!(resp.block_height, 450538);
+ assert_eq!(resp.pos, 710);
+ assert_eq!(resp.merkle.len(), 11);
+ assert_eq!(
+ resp.merkle[0],
+ [
+ 0x71, 0x3D, 0x6C, 0x7E, 0x6C, 0xE7, 0xBB, 0xEA, 0x70, 0x8D, 0x61, 0x16, 0x22, 0x31,
+ 0xEA, 0xA8, 0xEC, 0xB3, 0x1C, 0x4C, 0x5D, 0xD8, 0x4F, 0x81, 0xC2, 0x04, 0x09, 0xA9,
+ 0x00, 0x69, 0xCB, 0x24
+ ]
+ );
+
+ impl_test_conclusion!(test_case, client.stream);
+ }
+}
--- /dev/null
+use bitcoin::blockdata::block;
+use bitcoin::hashes::hex::FromHex;
+use bitcoin::hashes::{sha256, Hash};
+use bitcoin::{Script, Txid};
+
+use serde::{de, Deserialize, Serialize};
+
+static JSONRPC_2_0: &str = "2.0";
+
+#[derive(Serialize, Clone)]
+#[serde(untagged)]
+pub enum Param {
+ Usize(usize),
+ String(String),
+ Bool(bool),
+}
+
+#[derive(Serialize, Clone)]
+pub struct Request<'a> {
+ jsonrpc: &'static str,
+
+ pub id: usize,
+ pub method: &'a str,
+ pub params: Vec<Param>,
+}
+
+impl<'a> Request<'a> {
+ pub fn new(method: &'a str, params: Vec<Param>) -> Self {
+ Self {
+ id: 0,
+ jsonrpc: JSONRPC_2_0,
+ method,
+ params,
+ }
+ }
+
+ pub fn new_id(id: usize, method: &'a str, params: Vec<Param>) -> Self {
+ let mut instance = Self::new(method, params);
+ instance.id = id;
+
+ instance
+ }
+}
+
+pub type ScriptHash = [u8; 32];
+pub type ScriptStatus = [u8; 32];
+
+pub trait ToElectrumScriptHash {
+ fn to_electrum_scripthash(&self) -> ScriptHash;
+}
+
+impl ToElectrumScriptHash for Script {
+ fn to_electrum_scripthash(&self) -> ScriptHash {
+ let mut result = sha256::Hash::hash(self.as_bytes()).into_inner();
+ result.reverse();
+
+ result
+ }
+}
+
+fn from_hex<'de, T, D>(deserializer: D) -> Result<T, D::Error>
+where
+ T: FromHex,
+ D: de::Deserializer<'de>,
+{
+ let s = String::deserialize(deserializer)?;
+ T::from_hex(&s).map_err(de::Error::custom)
+}
+
+fn from_hex_array<'de, T, D>(deserializer: D) -> Result<Vec<T>, D::Error>
+where
+ T: FromHex + std::fmt::Debug,
+ D: de::Deserializer<'de>,
+{
+ let arr = Vec::<String>::deserialize(deserializer)?;
+
+ let results: Vec<Result<T, _>> = arr
+ .into_iter()
+ .map(|s| T::from_hex(&s).map_err(de::Error::custom))
+ .collect();
+
+ let mut answer = Vec::new();
+ for x in results.into_iter() {
+ answer.push(x?);
+ }
+
+ Ok(answer)
+}
+
+#[derive(Debug, Deserialize)]
+pub struct GetHistoryRes {
+ pub height: i32,
+ pub tx_hash: Txid,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct ListUnspentRes {
+ pub height: usize,
+ pub tx_pos: usize,
+ pub value: u64,
+ pub tx_hash: Txid,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct ServerFeaturesRes {
+ pub server_version: String,
+ #[serde(deserialize_with = "from_hex")]
+ pub genesis_hash: [u8; 32],
+ pub protocol_min: String,
+ pub protocol_max: String,
+ pub hash_function: Option<String>,
+ pub pruning: Option<i64>,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct GetHeadersRes {
+ pub max: usize,
+ pub count: usize,
+ #[serde(rename(deserialize = "hex"), deserialize_with = "from_hex")]
+ pub raw_headers: Vec<u8>,
+ #[serde(skip)]
+ pub headers: Vec<block::BlockHeader>,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct GetBalanceRes {
+ pub confirmed: u64,
+ pub unconfirmed: u64,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct GetMempoolRes {
+ pub fee: u64,
+ pub height: i32,
+ pub tx_hash: Txid,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct GetMerkleRes {
+ pub block_height: usize,
+ pub pos: usize,
+ #[serde(deserialize_with = "from_hex_array")]
+ pub merkle: Vec<[u8; 32]>,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct HeaderNotification {
+ pub height: usize,
+ #[serde(rename(serialize = "hex"))]
+ pub header: block::BlockHeader,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct ScriptNotification {
+ pub scripthash: ScriptHash,
+ pub status: ScriptStatus,
+}
+
+#[derive(Debug)]
+pub enum Error {
+ IOError(std::io::Error),
+ JSON(serde_json::error::Error),
+ Hex(bitcoin::hashes::hex::Error),
+ Protocol(serde_json::Value),
+ Bitcoin(bitcoin::consensus::encode::Error),
+ AlreadySubscribed(ScriptHash),
+ NotSubscribed(ScriptHash),
+ InvalidResponse(serde_json::Value),
+ Message(String),
+
+ #[cfg(feature = "ssl")]
+ InvalidSslMethod(openssl::error::ErrorStack),
+ #[cfg(feature = "ssl")]
+ SslHandshakeError(openssl::ssl::HandshakeError<std::net::TcpStream>),
+}
+
+macro_rules! impl_error {
+ ( $from:ty, $to:ident ) => {
+ impl std::convert::From<$from> for Error {
+ fn from(err: $from) -> Self {
+ Error::$to(err)
+ }
+ }
+ };
+}
+
+impl_error!(std::io::Error, IOError);
+impl_error!(serde_json::Error, JSON);
+impl_error!(bitcoin::hashes::hex::Error, Hex);
+impl_error!(bitcoin::consensus::encode::Error, Bitcoin);
projects / bdk / commitdiff