Problem: no functionality exists to dynamically fetch gas-prices

README.md

@@ -117,6 +117,10 @@ withdraw_confirm = { gas = 3000000, gas_price = 1000000000 }
 - `home/foreign.poll_interval` - specify how often home node should be polled for changes (in seconds, default: **1**)
 - `home/foreign.request_timeout` - specify request timeout (in seconds, default: **3600**)
 - `home/foreign.password` - path to the file containing a password for the validator's account (to decrypt the key from the keystore)
+- `home/foreign.gas_price_oracle_url` - the URL used to query the current gas-price for the home and foreign nodes, this service is known as the gas-price Oracle. This config option defaults to `None` if not supplied in the User's config TOML file. If this config value is `None`, no Oracle gas-price querying will occur, resulting in the config value for `home/foreign.default_gas_price` being used for all gas-prices.
+- `home/foreign.gas_price_timeout` - the number of seconds to wait for an HTTP response from the gas price oracle before using the default gas price. Defaults to `10 seconds`.
+- `home/foreign.gas_price_speed_type` - retrieve the gas-price corresponding to this speed when querying from an Oracle. Defaults to `fast`. The available values are: "instant", "fast", "standard", and "slow".
+- `home/foreign.default_gas_price` - the default gas price (in WEI) used in transactions with the home or foreign nodes. The `default_gas_price` is used when the Oracle cannot be reached. The default value is `15_000_000_000` WEI (ie. 15 GWEI).
 
 #### authorities options
 

bridge/Cargo.toml

@@ -25,6 +25,8 @@ keccak-hash = { git = "http://github.com/paritytech/parity", rev = "991f0ca" }
 ethcore-transaction = { git = "http://github.com/paritytech/parity", rev = "991f0ca" }
 itertools = "0.7"
 jsonrpc-core = "8.0"
+hyper = "0.11.27"
+hyper-tls = "0.1.3"
 
 [dev-dependencies]
 tempdir = "0.3"

bridge/src/bridge/deposit_relay.rs

@@ -42,7 +42,7 @@ enum DepositRelayState<T: Transport> {
 	Yield(Option<u64>),
 }
 
-pub fn create_deposit_relay<T: Transport + Clone>(app: Arc<App<T>>, init: &Database, foreign_balance: Arc<RwLock<Option<U256>>>, foreign_chain_id: u64) -> DepositRelay<T> {
+pub fn create_deposit_relay<T: Transport + Clone>(app: Arc<App<T>>, init: &Database, foreign_balance: Arc<RwLock<Option<U256>>>, foreign_chain_id: u64, foreign_gas_price: Arc<RwLock<u64>>) -> DepositRelay<T> {
 	let logs_init = api::LogStreamInit {
 		after: init.checked_deposit_relay,
 		request_timeout: app.config.home.request_timeout,
@@ -57,6 +57,7 @@ pub fn create_deposit_relay<T: Transport + Clone>(app: Arc<App<T>>, init: &Datab
 		app,
 		foreign_balance,
 		foreign_chain_id,
+		foreign_gas_price,
 	}
 }
 
@@ -67,6 +68,7 @@ pub struct DepositRelay<T: Transport> {
 	foreign_contract: Address,
 	foreign_balance: Arc<RwLock<Option<U256>>>,
 	foreign_chain_id: u64,
+	foreign_gas_price: Arc<RwLock<u64>>,
 }
 
 impl<T: Transport> Stream for DepositRelay<T> {
@@ -85,7 +87,11 @@ impl<T: Transport> Stream for DepositRelay<T> {
 					let item = try_stream!(self.logs.poll().map_err(|e| ErrorKind::ContextualizedError(Box::new(e), "polling home for deposits")));
 					let len = item.logs.len();
 					info!("got {} new deposits to relay", len);
-					let balance_required = U256::from(self.app.config.txs.deposit_relay.gas) * U256::from(self.app.config.txs.deposit_relay.gas_price) * U256::from(item.logs.len());
+
+					let gas = U256::from(self.app.config.txs.deposit_relay.gas);
+					let gas_price = U256::from(*self.foreign_gas_price.read().unwrap());
+					let balance_required = gas * gas_price * U256::from(item.logs.len());
+
 					if balance_required > *foreign_balance.as_ref().unwrap() {
 						return Err(ErrorKind::InsufficientFunds.into())
 					}
@@ -96,8 +102,8 @@ impl<T: Transport> Stream for DepositRelay<T> {
 						.into_iter()
 						.map(|payload| {
 							let tx = Transaction {
-								gas: self.app.config.txs.deposit_relay.gas.into(),
-								gas_price: self.app.config.txs.deposit_relay.gas_price.into(),
+								gas,
+								gas_price,
 								value: U256::zero(),
 								data: payload.0,
 								nonce: U256::zero(),

bridge/src/bridge/gas_price.rs

@@ -0,0 +1,98 @@
+use std::collections::HashMap;
+use std::time::{Duration, Instant};
+
+use futures::{Async, Future, Poll, Stream};
+use hyper::{Chunk, client::HttpConnector, Client, Uri};
+use hyper_tls::HttpsConnector;
+use serde_json as json;
+use tokio_core::reactor::Handle;
+use tokio_timer::{Interval, Timer, Timeout};
+
+use config::{GasPriceSpeed, Node};
+use error::Error;
+
+const CACHE_TIMEOUT_DURATION: Duration = Duration::from_secs(5 * 60);
+const REQUEST_TIMEOUT_DURATION: Duration = Duration::from_secs(30);
+
+enum State {
+    Initial,
+    WaitingForResponse(Timeout<Box<Future<Item = Chunk, Error = Error>>>),
+    Yield(Option<u64>),
+}
+
+pub struct GasPriceStream {
+    state: State,
+    client: Client<HttpsConnector<HttpConnector>>,
+    uri: Uri,
+    speed: GasPriceSpeed,
+    request_timer: Timer,
+    interval: Interval,
+}
+
+impl GasPriceStream {
+    pub fn new(node: &Node, handle: &Handle, timer: &Timer) -> Self {
+        let client = Client::configure()
+            .connector(HttpsConnector::new(4, handle).unwrap())
+            .build(handle);
+
+        let uri: Uri = node.gas_price_oracle_url.clone().unwrap().parse().unwrap();
+
+        GasPriceStream {
+            state: State::Initial,
+            client,
+            uri,
+            speed: node.gas_price_speed,
+            request_timer: timer.clone(),
+            interval: timer.interval_at(Instant::now(), CACHE_TIMEOUT_DURATION),
+        }
+    }
+}
+
+impl Stream for GasPriceStream {
+    type Item = u64;
+    type Error = Error;
+
+    fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error> {
+        loop {
+            let next_state = match self.state {
+                State::Initial => {
+                    let _ = try_stream!(self.interval.poll());
+
+                    let request: Box<Future<Item = Chunk, Error = Error>> =
+                        Box::new(
+                            self.client.get(self.uri.clone())
+                                .and_then(|resp| resp.body().concat2())
+                                .map_err(|e| e.into())
+                        );
+
+                    let request_future = self.request_timer
+                        .timeout(request, REQUEST_TIMEOUT_DURATION);
+
+                    State::WaitingForResponse(request_future)
+                },
+                State::WaitingForResponse(ref mut request_future) => {
+                    match request_future.poll() {
+                        Ok(Async::NotReady) => return Ok(Async::NotReady),
+                        Ok(Async::Ready(chunk)) => {
+                            let json_obj: HashMap<String, json::Value> = json::from_slice(&chunk)?;
+
+                            let gas_price = match json_obj.get(self.speed.as_str()) {
+                                Some(json::Value::Number(price)) => (price.as_f64().unwrap() * 1_000_000_000.0).trunc() as u64,
+                                _ => unreachable!(),
+                            };
+
+                            State::Yield(Some(gas_price))
+                        },
+                        Err(e) => panic!(e), 
+                    }
+                },
+                State::Yield(ref mut opt) => match opt.take() {
+					None => State::Initial,
+					price => return Ok(Async::Ready(price)),
+				}
+            };
+
+            self.state = next_state;
+        }
+    }
+}