<!-- cargo-rdme start -->

This is a convenience crate for handling http requests and errors.
# Examples
```rust
use ddf_blocking_http_client::Client;
use ddf_blocking_http_client::HttpResult;
use serde::Deserialize;

use dotenv::dotenv;
use std::env;

// dotenv is being used for lack of an example not requiring private keys and public wallet addresses.
// dotenv is not required for this crate to work.
dotenv::dotenv().ok();
let api_key = env::var("API_KEY").unwrap();
let wallet_address = env::var("PUBLIC_WALLET_ADDRESS").unwrap();

#[derive(Debug, Deserialize)]
struct Balance {
    result: String
}

let client = Client::new();

let url = 
    &[
        "https://api.etherscan.io/api",
        "?module=account",
        "&action=balance",
        "&address=", &wallet_address,
        "&tag=latest",
        "&apikey=", &api_key
    ].concat();

// Here is the main feature, Balance is the data structure expected back, defined above.
// You define your own struct and use the serde crate and tag the struct with #[derive(Deserialize)]
// and put the name of your struct where our example is using "Balance".
// the 10 means we are going to try 10 times, if there is a too_many_requests response, or 
// an unknown error (perhaps our crate just doesn't handle it yet) then it will wait 1 second and try again.
// each time it will double the wait time. The return type is HttpResult<T>

let balance = client.get::<Balance>(url, 10).unwrap().result;

dbg!(&balance);

// If you are unsure the shape of the data, you can at first use the "get_as_text" function.
// Here is an example of that "get_as_text" function, so you can get a look at all the fields to base your struct off of:

let balance = client.get_as_text(&url);

dbg!(&balance);
```

<!-- cargo-rdme end -->