Use daemon's relayfee instead of hardcoding

src/bin/electrs.rs

@@ -60,13 +60,17 @@ fn run_server(config: &Config) -> Result<()> {
     let app = App::new(store, index, daemon, &config)?;
     let tx_cache = TransactionCache::new(config.tx_cache_size, &metrics);
     let query = Query::new(app.clone(), &metrics, tx_cache, config.txid_limit);
+    let relayfee = query.get_relayfee()?;
+    debug!("relayfee: {} BTC", relayfee);
 
     let mut server = None; // Electrum RPC server
     loop {
         app.update(&signal)?;
         query.update_mempool()?;
         server
-            .get_or_insert_with(|| RPC::start(config.electrum_rpc_addr, query.clone(), &metrics))
+            .get_or_insert_with(|| {
+                RPC::start(config.electrum_rpc_addr, query.clone(), &metrics, relayfee)
+            })
             .notify(); // update subscribed clients
         if let Err(err) = signal.wait(Duration::from_secs(5)) {
             info!("stopping server: {}", err);

src/daemon.rs

@@ -113,6 +113,7 @@ struct BlockchainInfo {
 struct NetworkInfo {
     version: u64,
     subversion: String,
+    relayfee: f64, // in BTC
 }
 
 pub struct MempoolEntry {
@@ -455,6 +456,10 @@ impl Daemon {
         Ok(self.getnetworkinfo()?.subversion)
     }
 
+    pub fn get_relayfee(&self) -> Result<f64> {
+        Ok(self.getnetworkinfo()?.relayfee)
+    }
+
     pub fn getbestblockhash(&self) -> Result<Sha256dHash> {
         parse_hash(&self.request("getbestblockhash", json!([]))?).chain_err(|| "invalid blockhash")
     }

src/query.rs

@@ -520,4 +520,8 @@ impl Query {
     pub fn get_banner(&self) -> Result<String> {
         self.app.get_banner()
     }
+
+    pub fn get_relayfee(&self) -> Result<f64> {
+        self.app.daemon().get_relayfee()
+    }
 }

src/rpc.rs

@@ -77,6 +77,7 @@ struct Connection {
     addr: SocketAddr,
     chan: SyncChannel<Message>,
     stats: Arc<Stats>,
+    relayfee: f64,
 }
 
 impl Connection {
@@ -85,6 +86,7 @@ impl Connection {
         stream: TcpStream,
         addr: SocketAddr,
         stats: Arc<Stats>,
+        relayfee: f64,
     ) -> Connection {
         Connection {
             query,
@@ -94,6 +96,7 @@ impl Connection {
             addr,
             chan: SyncChannel::new(10),
             stats,
+            relayfee,
         }
     }
 
@@ -195,7 +198,7 @@ impl Connection {
     }
 
     fn blockchain_relayfee(&self) -> Result<Value> {
-        Ok(json!(0.0)) // allow sending transactions with any fee.
+        Ok(json!(self.relayfee))
     }
 
     fn blockchain_scripthash_subscribe(&mut self, params: &[Value]) -> Result<Value> {
@@ -526,7 +529,7 @@ impl RPC {
         chan
     }
 
-    pub fn start(addr: SocketAddr, query: Arc<Query>, metrics: &Metrics) -> RPC {
+    pub fn start(addr: SocketAddr, query: Arc<Query>, metrics: &Metrics, relayfee: f64) -> RPC {
         let stats = Arc::new(Stats {
             latency: metrics.histogram_vec(
                 HistogramOpts::new("electrs_electrum_rpc", "Electrum RPC latency (seconds)"),
@@ -563,7 +566,7 @@ impl RPC {
 
                         spawn_thread("peer", move || {
                             info!("[{}] connected peer #{}", addr, handle_id);
-                            let conn = Connection::new(query, stream, addr, stats);
+                            let conn = Connection::new(query, stream, addr, stats, relayfee);
                             senders
                                 .lock()
                                 .unwrap()