#[cfg(all(feature = "native-tls", feature = "rustls-tls"))]
compile_error!("features `native-tls` and `rustls-tls` cannot be enabled together");
#[cfg(not(any(feature = "native-tls", feature = "rustls-tls")))]
compile_error!("enable either the `native-tls` or `rustls-tls` feature");
mod auth;
#[cfg(test)]
mod tests;
pub mod error;
pub mod rest;
pub mod types;
pub mod ws;
pub use error::{Error, Result};
pub use types::{OrderType, Side};
use std::time::Duration;
pub const DEFAULT_REST_URL: &str = "https://api.bitvavo.com/v2";
pub const DEFAULT_WS_URL: &str = "wss://ws.bitvavo.com/v2/";
pub const DEFAULT_ACCESS_WINDOW_MS: u64 = 10_000;
#[derive(Clone)]
pub struct ClientConfig {
pub api_key: Option<String>,
pub api_secret: Option<String>,
pub rest_url: String,
pub ws_url: String,
pub access_window_ms: u64,
pub timeout: Duration,
pub allow_insecure_transport: bool,
}
impl std::fmt::Debug for ClientConfig {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("ClientConfig")
.field("api_key", &self.api_key.as_ref().map(|_| "<redacted>"))
.field(
"api_secret",
&self.api_secret.as_ref().map(|_| "<redacted>"),
)
.field("rest_url", &self.rest_url)
.field("ws_url", &self.ws_url)
.field("access_window_ms", &self.access_window_ms)
.field("timeout", &self.timeout)
.field("allow_insecure_transport", &self.allow_insecure_transport)
.finish()
}
}
impl Default for ClientConfig {
fn default() -> Self {
Self {
api_key: None,
api_secret: None,
rest_url: DEFAULT_REST_URL.to_string(),
ws_url: DEFAULT_WS_URL.to_string(),
access_window_ms: DEFAULT_ACCESS_WINDOW_MS,
timeout: Duration::from_secs(30),
allow_insecure_transport: false,
}
}
}
impl ClientConfig {
pub fn new() -> Self {
Self::default()
}
pub fn with_credentials(api_key: impl Into<String>, api_secret: impl Into<String>) -> Self {
Self {
api_key: Some(api_key.into()),
api_secret: Some(api_secret.into()),
..Self::default()
}
}
pub fn from_env() -> Self {
let api_key = std::env::var("BITVAVO_API_KEY")
.ok()
.filter(|v| !v.is_empty());
let api_secret = std::env::var("BITVAVO_API_SECRET")
.ok()
.filter(|v| !v.is_empty());
Self {
api_key,
api_secret,
..Self::default()
}
}
pub fn rest_url(mut self, url: impl Into<String>) -> Self {
self.rest_url = url.into();
self
}
pub fn ws_url(mut self, url: impl Into<String>) -> Self {
self.ws_url = url.into();
self
}
pub fn access_window_ms(mut self, window: u64) -> Self {
self.access_window_ms = window;
self
}
pub fn timeout(mut self, timeout: Duration) -> Self {
self.timeout = timeout;
self
}
pub fn danger_allow_insecure_transport(mut self, allow: bool) -> Self {
self.allow_insecure_transport = allow;
self
}
pub fn has_credentials(&self) -> bool {
self.api_key.is_some() && self.api_secret.is_some()
}
pub(crate) fn credentials(&self) -> Result<(&str, &str)> {
match (self.api_key.as_deref(), self.api_secret.as_deref()) {
(Some(key), Some(secret)) => Ok((key, secret)),
_ => Err(Error::MissingCredentials),
}
}
}
pub(crate) fn validate_transport_url(
url: &str,
transport: &'static str,
secure_scheme: &'static str,
insecure_scheme: &'static str,
allow_insecure: bool,
) -> Result<()> {
let parsed = reqwest::Url::parse(url).map_err(|_| Error::InvalidUrl { transport })?;
let scheme = parsed.scheme();
if scheme == secure_scheme || allow_insecure && scheme == insecure_scheme {
return Ok(());
}
Err(Error::InsecureTransport {
transport,
required_scheme: secure_scheme,
})
}
#[cfg(test)]
mod transport_tests {
use super::*;
#[test]
fn accepts_secure_transport_urls() {
assert!(
validate_transport_url("https://example.com", "REST", "https", "http", false).is_ok()
);
assert!(
validate_transport_url("wss://example.com", "WebSocket", "wss", "ws", false).is_ok()
);
}
#[test]
fn rejects_unencrypted_transport_urls() {
assert!(matches!(
validate_transport_url("http://example.com", "REST", "https", "http", false),
Err(Error::InsecureTransport { .. })
));
assert!(matches!(
validate_transport_url("ws://example.com", "WebSocket", "wss", "ws", false),
Err(Error::InsecureTransport { .. })
));
}
#[test]
fn permits_explicit_insecure_transport() {
assert!(validate_transport_url("http://127.0.0.1", "REST", "https", "http", true).is_ok());
assert!(validate_transport_url("ws://127.0.0.1", "WebSocket", "wss", "ws", true).is_ok());
}
#[test]
fn rejects_invalid_and_unsupported_urls() {
assert!(matches!(
validate_transport_url("not a URL", "REST", "https", "http", false),
Err(Error::InvalidUrl { .. })
));
assert!(matches!(
validate_transport_url("ftp://example.com", "REST", "https", "http", true),
Err(Error::InsecureTransport { .. })
));
}
#[test]
fn rest_client_rejects_unencrypted_url() {
let config = ClientConfig::new().rest_url("http://example.com");
assert!(matches!(
rest::RestClient::new(config),
Err(Error::InsecureTransport { .. })
));
}
#[tokio::test]
async fn websocket_client_rejects_unencrypted_url() {
let config = ClientConfig::new().ws_url("ws://example.com");
assert!(matches!(
ws::WsClient::connect(config).await,
Err(Error::InsecureTransport { .. })
));
}
}