81 lines
3.1 KiB
Rust
81 lines
3.1 KiB
Rust
use ethers::providers::{Authorization, ConnectionDetails};
|
|
use std::time::Duration;
|
|
use url::Url;
|
|
|
|
use crate::errors::Web3ProxyResult;
|
|
|
|
pub type EthersHttpProvider = ethers::providers::Provider<ethers::providers::Http>;
|
|
pub type EthersWsProvider = ethers::providers::Provider<ethers::providers::Ws>;
|
|
|
|
pub fn extract_auth(url: &mut Url) -> Option<Authorization> {
|
|
if let Some(pass) = url.password().map(|x| x.to_string()) {
|
|
// to_string is needed because we are going to remove these items from the url
|
|
let user = url.username().to_string();
|
|
|
|
// clear username and password from the url
|
|
url.set_username("")
|
|
.expect("unable to clear username on websocket");
|
|
url.set_password(None)
|
|
.expect("unable to clear password on websocket");
|
|
|
|
// keep them
|
|
Some(Authorization::basic(user, pass))
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
|
|
/// Note, if the http url has an authority the http_client param is ignored and a dedicated http_client will be used
|
|
/// TODO: take a reqwest::Client or a reqwest::ClientBuilder. that way we can do things like set compression even when auth is set
|
|
pub fn connect_http(
|
|
mut url: Url,
|
|
http_client: Option<reqwest::Client>,
|
|
interval: Duration,
|
|
) -> Web3ProxyResult<EthersHttpProvider> {
|
|
let auth = extract_auth(&mut url);
|
|
|
|
let mut provider = if url.scheme().starts_with("http") {
|
|
let provider = if let Some(auth) = auth {
|
|
// TODO: there are two "HttpClientError" in ethers. this one is not in the prelude
|
|
ethers::providers::Http::new_with_auth(url, auth)
|
|
.map_err(|err| anyhow::anyhow!("http client error: {:?}", err))?
|
|
} else if let Some(http_client) = http_client {
|
|
ethers::providers::Http::new_with_client(url, http_client)
|
|
} else {
|
|
ethers::providers::Http::new(url)
|
|
};
|
|
|
|
// TODO: i don't think this interval matters for our uses, but we should probably set it to like `block time / 2`
|
|
ethers::providers::Provider::new(provider).interval(Duration::from_secs(2))
|
|
} else {
|
|
return Err(anyhow::anyhow!("only http servers are supported. cannot use {}", url).into());
|
|
};
|
|
|
|
provider.set_interval(interval);
|
|
|
|
Ok(provider)
|
|
}
|
|
|
|
pub async fn connect_ws(mut url: Url, reconnects: usize) -> Web3ProxyResult<EthersWsProvider> {
|
|
let auth = extract_auth(&mut url);
|
|
|
|
let provider = if url.scheme().starts_with("ws") {
|
|
let provider = if auth.is_some() {
|
|
let connection_details = ConnectionDetails::new(url.as_str(), auth);
|
|
|
|
// if they error, we do our own reconnection with backoff
|
|
ethers::providers::Ws::connect_with_reconnects(connection_details, reconnects).await?
|
|
} else {
|
|
ethers::providers::Ws::connect_with_reconnects(url.as_str(), reconnects).await?
|
|
};
|
|
|
|
// TODO: dry this up (needs https://github.com/gakonst/ethers-rs/issues/592)
|
|
// TODO: i don't think this interval matters
|
|
ethers::providers::Provider::new(provider)
|
|
} else {
|
|
return Err(anyhow::anyhow!("ws servers are supported").into());
|
|
};
|
|
|
|
Ok(provider)
|
|
}
|