use std::collections::HashMap;
use std::env;
use std::time::Duration;
use uuid::Uuid;
use crate::error::GodarkError;
const DEFAULT_EDGE_BASE_URL: &str = "wss://api.godark-dex.com";
const DEVNET_EDGE_BASE_URL: &str = "wss://api.devnet.godark-dex.com";
const LOCALNET_EDGE_BASE_URL: &str = "ws://127.0.0.1:13300";
const TESTNET_HPKE_STATIC_PUBLIC_KEY_HEX: &str =
"a9fdd7f26c0de36d82811e9fe1df2509960cd5b25eef037355e209b9222bea7d";
const DEVNET_HPKE_STATIC_PUBLIC_KEY_HEX: &str =
"a6807e2f6cd04b54cc19be2fd4faea2a1239f1e2896912d91222678ab54cdd45";
const DEFAULT_SYMBOLS_JSON: &str = include_str!("../shared/symbols.json");
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
#[non_exhaustive]
pub enum Environment {
#[default]
Testnet,
Devnet,
Localnet,
}
impl Environment {
#[must_use]
pub const fn edge_base_url(self) -> &'static str {
match self {
Self::Testnet => DEFAULT_EDGE_BASE_URL,
Self::Devnet => DEVNET_EDGE_BASE_URL,
Self::Localnet => LOCALNET_EDGE_BASE_URL,
}
}
#[must_use]
pub const fn rest_base_url(self) -> &'static str {
match self {
Self::Testnet => "https://api.godark-dex.com",
Self::Devnet => "https://api.devnet.godark-dex.com",
Self::Localnet => "http://127.0.0.1:13300",
}
}
#[must_use]
pub const fn hpke_static_public_key_hex(self) -> Option<&'static str> {
match self {
Self::Testnet => Some(TESTNET_HPKE_STATIC_PUBLIC_KEY_HEX),
Self::Devnet => Some(DEVNET_HPKE_STATIC_PUBLIC_KEY_HEX),
Self::Localnet => None,
}
}
}
#[derive(Debug, Clone)]
pub struct TransportConfig {
pub tls_skip_verify: bool,
pub extra_headers: HashMap<String, String>,
pub connect_timeout: Duration,
pub command_timeout: Duration,
pub stale_timeout: Duration,
pub heartbeat_interval: Duration,
}
impl Default for TransportConfig {
fn default() -> Self {
Self {
tls_skip_verify: false,
extra_headers: HashMap::new(),
connect_timeout: Duration::from_secs(30),
command_timeout: Duration::from_secs(30),
stale_timeout: Duration::from_secs(60),
heartbeat_interval: Duration::from_secs(30),
}
}
}
#[derive(Debug, Clone)]
#[non_exhaustive]
pub struct GodarkConfig {
pub auth_token: String,
pub base_url: String,
pub auto_reconnect: bool,
pub symbol_map: HashMap<String, u64>,
pub transport: TransportConfig,
pub user_uuid: Option<Uuid>,
pub hpke_static_public_key_hex: Option<String>,
pub(crate) place_order_terminal_timeout: Duration,
pub(crate) explicit_symbol_map: bool,
}
impl GodarkConfig {
#[must_use]
pub fn place_order_terminal_timeout(&self) -> Duration {
self.place_order_terminal_timeout
}
}
pub struct GodarkConfigBuilder {
api_key: Option<String>,
api_key_id: Option<String>,
api_secret: Option<String>,
passphrase: Option<String>,
base_url: Option<String>,
environment: Environment,
auto_reconnect: bool,
symbol_map: HashMap<String, u64>,
transport: TransportConfig,
user_uuid: Option<Uuid>,
hpke_static_public_key_hex: Option<String>,
place_order_terminal_timeout: Option<Duration>,
explicit_symbol_map: bool,
}
impl GodarkConfigBuilder {
pub fn new() -> Self {
let symbols: HashMap<String, u64> =
serde_json::from_str(DEFAULT_SYMBOLS_JSON).expect("default symbols.json must be valid");
Self {
api_key: None,
api_key_id: None,
api_secret: None,
passphrase: None,
base_url: None,
environment: Environment::Testnet,
auto_reconnect: true,
symbol_map: symbols,
transport: TransportConfig::default(),
user_uuid: None,
hpke_static_public_key_hex: None,
place_order_terminal_timeout: None,
explicit_symbol_map: false,
}
}
pub fn environment(mut self, environment: Environment) -> Self {
self.environment = environment;
self
}
pub fn transport(mut self, transport: TransportConfig) -> Self {
self.transport = transport;
self
}
pub fn api_key(mut self, key: impl Into<String>) -> Self {
self.api_key = Some(key.into());
self
}
pub fn api_key_id(mut self, id: impl Into<String>) -> Self {
self.api_key_id = Some(id.into());
self
}
pub fn api_secret(mut self, secret: impl Into<String>) -> Self {
self.api_secret = Some(secret.into());
self
}
pub fn passphrase(mut self, pp: impl Into<String>) -> Self {
self.passphrase = Some(pp.into());
self
}
pub fn base_url(mut self, url: impl Into<String>) -> Self {
self.base_url = Some(url.into());
self
}
pub fn auto_reconnect(mut self, enabled: bool) -> Self {
self.auto_reconnect = enabled;
self
}
pub fn place_order_terminal_timeout(mut self, timeout: Duration) -> Self {
self.place_order_terminal_timeout = Some(timeout);
self
}
pub fn user_uuid(mut self, uuid: impl Into<String>) -> Self {
self.user_uuid = Uuid::parse_str(&uuid.into()).ok();
self
}
pub fn hpke_static_public_key_hex(mut self, key: impl Into<String>) -> Self {
self.hpke_static_public_key_hex = Some(key.into());
self
}
pub fn symbol(mut self, name: impl Into<String>, id: u64) -> Self {
self.explicit_symbol_map = true;
self.symbol_map.insert(name.into(), id);
self
}
pub fn build(self) -> Result<GodarkConfig, GodarkError> {
let auth_token = match (self.api_key_id, self.api_secret, self.api_key) {
(Some(id), Some(secret), None) => {
let pp = resolve_passphrase(self.passphrase.as_deref()).ok_or_else(|| {
GodarkError::Config(
"passphrase is required when using api_key_id and api_secret".into(),
)
})?;
format!("{id}:{secret}:{pp}")
}
(None, None, Some(key)) => {
if self
.passphrase
.as_ref()
.is_some_and(|pp| !pp.trim().is_empty())
{
return Err(GodarkError::Config(
"passphrase must not be set when using legacy api_key".into(),
));
}
key
}
(Some(_), None, _) | (None, Some(_), _) => {
return Err(GodarkError::Config(
"api_key_id and api_secret must be provided together".into(),
));
}
(Some(_), Some(_), Some(_)) => {
return Err(GodarkError::Config(
"use either api_key or (api_key_id, api_secret), not both".into(),
));
}
(None, None, None) => {
return Err(GodarkError::Config(
"provide api_key or both api_key_id and api_secret".into(),
));
}
};
let base_url = resolve_edge_base_url_with_default(
self.base_url.as_deref(),
self.environment.edge_base_url(),
);
let user_uuid = self.user_uuid.or_else(resolve_user_uuid_env);
let environment = self.environment;
let pin_env = if self
.base_url
.as_deref()
.map(str::trim)
.filter(|s| !s.is_empty())
.is_some()
{
infer_environment_from_edge_url(&base_url)
} else {
environment
};
let hpke_static_public_key_hex = self
.hpke_static_public_key_hex
.or_else(resolve_hpke_static_public_key_env)
.or_else(|| pin_env.hpke_static_public_key_hex().map(str::to_string));
let place_order_terminal_timeout = self
.place_order_terminal_timeout
.unwrap_or(self.transport.command_timeout);
if place_order_terminal_timeout.is_zero() {
return Err(GodarkError::Config(
"place_order_terminal_timeout must be greater than zero".into(),
));
}
Ok(GodarkConfig {
auth_token,
base_url,
auto_reconnect: self.auto_reconnect,
symbol_map: self.symbol_map,
transport: self.transport,
user_uuid,
hpke_static_public_key_hex,
place_order_terminal_timeout,
explicit_symbol_map: self.explicit_symbol_map,
})
}
}
impl Default for GodarkConfigBuilder {
fn default() -> Self {
Self::new()
}
}
fn infer_environment_from_edge_url(base: &str) -> Environment {
let mut host = base.trim().to_ascii_lowercase();
for prefix in ["https://", "http://", "wss://", "ws://"] {
if let Some(rest) = host.strip_prefix(prefix) {
host = rest.to_string();
break;
}
}
if let Some(i) = host.find('/') {
host.truncate(i);
}
if let Some(i) = host.find(':') {
host.truncate(i);
}
if host == "127.0.0.1" || host == "localhost" || host.ends_with(".localhost") {
return Environment::Localnet;
}
if host.contains("devnet") {
return Environment::Devnet;
}
if host.contains("godark-dex.com") {
return Environment::Testnet;
}
Environment::Testnet
}
pub fn resolve_passphrase(explicit: Option<&str>) -> Option<String> {
if let Some(v) = explicit {
let trimmed = v.trim();
if !trimmed.is_empty() {
return Some(trimmed.to_string());
}
}
for key in &["GODARK_PASSPHRASE", "GDX_PASSPHRASE"] {
if let Ok(v) = env::var(key) {
let trimmed = v.trim().to_string();
if !trimmed.is_empty() {
return Some(trimmed);
}
}
}
None
}
fn resolve_user_uuid_env() -> Option<Uuid> {
for key in &["GODARK_USER_UUID", "GDX_USER_UUID"] {
if let Ok(v) = env::var(key) {
if let Ok(u) = Uuid::parse_str(v.trim()) {
return Some(u);
}
}
}
None
}
fn resolve_hpke_static_public_key_env() -> Option<String> {
for key in &[
"GDX_HPKE_STATIC_PUBLIC_KEY",
"GDX_HPKE_STATIC_PUBKEY",
"GODARK_HPKE_STATIC_PUBLIC_KEY",
"VITE_GDX_HPKE_STATIC_PUBKEY",
] {
if let Ok(value) = env::var(key) {
let value = value.trim();
if !value.is_empty() {
return Some(value.to_string());
}
}
}
None
}
#[cfg(test)]
fn resolve_edge_base_url(explicit: Option<&str>) -> String {
resolve_edge_base_url_with_default(explicit, DEFAULT_EDGE_BASE_URL)
}
fn resolve_edge_base_url_with_default(explicit: Option<&str>, default: &str) -> String {
if let Some(url) = explicit {
let trimmed = url.trim();
if !trimmed.is_empty() {
return trimmed.to_string();
}
}
for key in &["GODARK_EDGE_URL", "GDX_EDGE_URL"] {
if let Ok(v) = env::var(key) {
let trimmed = v.trim().to_string();
if !trimmed.is_empty() {
return trimmed;
}
}
}
default.to_string()
}
pub(crate) fn ws_url(base_url: &str) -> String {
let url = base_url.trim_end_matches('/');
if url.ends_with("/ws/v1") {
url.to_string()
} else if let Some(stripped) = url.strip_suffix("/ws") {
format!("{stripped}/ws/v1")
} else {
format!("{url}/ws/v1")
}
}
pub(crate) fn gomarket_url(base_url: &str) -> String {
let mut url = base_url.trim_end_matches('/').to_string();
if let Some(stripped) = url.strip_suffix("/ws/v1") {
url = stripped.to_string();
} else if let Some(stripped) = url.strip_suffix("/ws") {
url = stripped.to_string();
}
format!("{url}/ws/gomarket")
}
pub fn is_docs_wire_url(url: &str) -> bool {
let cut = url.split(['?', '#']).next().unwrap_or(url);
cut.trim_end_matches('/').ends_with("/ws/v1")
}
fn env_first(keys: &[&str]) -> Option<String> {
for key in keys {
if let Ok(v) = env::var(key) {
let trimmed = v.trim().to_string();
if !trimmed.is_empty() {
return Some(trimmed);
}
}
}
None
}
fn env_truthy(keys: &[&str]) -> bool {
for key in keys {
if let Ok(v) = env::var(key) {
let raw = v.trim().to_lowercase();
if matches!(raw.as_str(), "1" | "true" | "yes" | "on") {
return true;
}
}
}
false
}
pub fn resolve_market_data_ws_url(base_url: &str) -> String {
if let Some(override_url) = env_first(&["GODARK_MARKET_DATA_WS_URL", "GDX_MARKET_DATA_WS_URL"])
{
return override_url;
}
if env_truthy(&[
"GODARK_MARKET_DATA_USE_GOMARKET",
"GDX_MARKET_DATA_USE_GOMARKET",
]) {
return gomarket_url(base_url.trim());
}
ws_url(base_url.trim())
}
#[cfg(test)]
mod tests {
use std::collections::HashMap;
use std::sync::Mutex;
use super::{
gomarket_url, resolve_edge_base_url, resolve_passphrase, ws_url, Environment,
GodarkConfigBuilder, GodarkError,
};
static ENV_LOCK: Mutex<()> = Mutex::new(());
#[test]
fn test_builder_api_key_pair() {
let cfg = GodarkConfigBuilder::new()
.api_key_id("id")
.api_secret("secret")
.passphrase("pp")
.build()
.unwrap();
assert_eq!(cfg.auth_token, "id:secret:pp");
}
#[test]
fn test_builder_api_key_pair_requires_passphrase() {
let _guard = ENV_LOCK.lock().unwrap();
let old_g = std::env::var("GODARK_PASSPHRASE").ok();
let old_x = std::env::var("GDX_PASSPHRASE").ok();
std::env::remove_var("GODARK_PASSPHRASE");
std::env::remove_var("GDX_PASSPHRASE");
let err = GodarkConfigBuilder::new()
.api_key_id("id")
.api_secret("secret")
.build()
.unwrap_err();
assert!(matches!(err, GodarkError::Config(ref msg) if msg.contains("passphrase")));
if let Some(v) = old_g {
std::env::set_var("GODARK_PASSPHRASE", v);
} else {
std::env::remove_var("GODARK_PASSPHRASE");
}
if let Some(v) = old_x {
std::env::set_var("GDX_PASSPHRASE", v);
} else {
std::env::remove_var("GDX_PASSPHRASE");
}
}
#[test]
fn test_builder_legacy_rejects_passphrase() {
let err = GodarkConfigBuilder::new()
.api_key("k")
.passphrase("pp")
.build()
.unwrap_err();
assert!(matches!(err, GodarkError::Config(ref msg) if msg.contains("passphrase")));
}
#[test]
fn test_builder_api_key_pair_passphrase_from_env() {
let _guard = ENV_LOCK.lock().unwrap();
let old_g = std::env::var("GODARK_PASSPHRASE").ok();
let old_x = std::env::var("GDX_PASSPHRASE").ok();
std::env::remove_var("GODARK_PASSPHRASE");
std::env::set_var("GDX_PASSPHRASE", "env-pp");
let cfg = GodarkConfigBuilder::new()
.api_key_id("id")
.api_secret("secret")
.build()
.unwrap();
assert_eq!(cfg.auth_token, "id:secret:env-pp");
if let Some(v) = old_g {
std::env::set_var("GODARK_PASSPHRASE", v);
} else {
std::env::remove_var("GODARK_PASSPHRASE");
}
if let Some(v) = old_x {
std::env::set_var("GDX_PASSPHRASE", v);
} else {
std::env::remove_var("GDX_PASSPHRASE");
}
}
#[test]
fn test_resolve_passphrase_prefers_constructor() {
let _guard = ENV_LOCK.lock().unwrap();
std::env::set_var("GDX_PASSPHRASE", "from-env");
assert_eq!(
resolve_passphrase(Some("explicit")),
Some("explicit".into())
);
std::env::remove_var("GDX_PASSPHRASE");
}
#[test]
fn test_resolve_passphrase_from_godark_env() {
let _guard = ENV_LOCK.lock().unwrap();
std::env::set_var("GODARK_PASSPHRASE", "godark-pw");
std::env::set_var("GDX_PASSPHRASE", "gdx-pw");
assert_eq!(resolve_passphrase(None), Some("godark-pw".into()));
std::env::remove_var("GODARK_PASSPHRASE");
std::env::remove_var("GDX_PASSPHRASE");
}
#[test]
fn test_builder_place_order_terminal_timeout_default() {
let cfg = GodarkConfigBuilder::new().api_key("k").build().unwrap();
assert_eq!(
cfg.place_order_terminal_timeout(),
cfg.transport.command_timeout
);
}
#[test]
fn test_builder_place_order_terminal_timeout_custom() {
use std::time::Duration;
let cfg = GodarkConfigBuilder::new()
.api_key("k")
.place_order_terminal_timeout(Duration::from_secs(5))
.build()
.unwrap();
assert_eq!(cfg.place_order_terminal_timeout(), Duration::from_secs(5));
}
#[test]
fn test_builder_legacy_api_key() {
let cfg = GodarkConfigBuilder::new().api_key("mykey").build().unwrap();
assert_eq!(cfg.auth_token, "mykey");
}
#[test]
fn test_builder_both_auth_modes_errors() {
let err = GodarkConfigBuilder::new()
.api_key("k")
.api_key_id("id")
.api_secret("secret")
.build()
.unwrap_err();
assert!(matches!(err, GodarkError::Config(ref msg) if msg.contains("not both")));
}
#[test]
fn test_builder_no_auth_errors() {
let err = GodarkConfigBuilder::new().build().unwrap_err();
assert!(matches!(err, GodarkError::Config(ref msg) if msg.contains("provide api_key")));
}
#[test]
fn test_builder_incomplete_pair_errors() {
let err = GodarkConfigBuilder::new()
.api_key_id("id")
.build()
.unwrap_err();
assert!(matches!(err, GodarkError::Config(ref msg) if msg.contains("together")));
}
#[test]
fn test_builder_default_symbols() {
let cfg = GodarkConfigBuilder::new().api_key("k").build().unwrap();
assert_eq!(cfg.symbol_map.get("BTC-USDC-PERP"), Some(&1));
assert_eq!(cfg.symbol_map.get("ETH-USDC-PERP"), Some(&2));
assert_eq!(cfg.symbol_map.get("SOL-USDC-PERP"), Some(&5));
}
#[test]
fn test_default_symbols_from_shared_json() {
let raw: HashMap<String, u64> =
serde_json::from_str(super::DEFAULT_SYMBOLS_JSON).expect("parse");
assert_eq!(raw.len(), 3);
}
#[test]
fn test_builder_custom_symbol() {
let cfg = GodarkConfigBuilder::new()
.api_key("k")
.symbol("DOGE-USDC-PERP", 8)
.build()
.unwrap();
assert_eq!(cfg.symbol_map.get("DOGE-USDC-PERP"), Some(&8));
}
#[test]
fn test_builder_auto_reconnect_default() {
let cfg = GodarkConfigBuilder::new().api_key("k").build().unwrap();
assert!(cfg.auto_reconnect);
}
#[test]
fn test_builder_default_environment_uses_baked_hpke_pin() {
let _guard = ENV_LOCK.lock().unwrap();
for key in [
"GDX_HPKE_STATIC_PUBLIC_KEY",
"GDX_HPKE_STATIC_PUBKEY",
"GODARK_HPKE_STATIC_PUBLIC_KEY",
"VITE_GDX_HPKE_STATIC_PUBKEY",
"GODARK_EDGE_URL",
"GDX_EDGE_URL",
] {
std::env::remove_var(key);
}
let cfg = GodarkConfigBuilder::new()
.api_key_id("id")
.api_secret("secret")
.passphrase("pp")
.build()
.unwrap();
assert_eq!(cfg.base_url, "wss://api.godark-dex.com");
assert_eq!(
cfg.hpke_static_public_key_hex.as_deref(),
Some(super::TESTNET_HPKE_STATIC_PUBLIC_KEY_HEX)
);
}
#[test]
fn test_builder_devnet_url_and_baked_hpke_pin() {
let _guard = ENV_LOCK.lock().unwrap();
for key in [
"GDX_HPKE_STATIC_PUBLIC_KEY",
"GDX_HPKE_STATIC_PUBKEY",
"GODARK_HPKE_STATIC_PUBLIC_KEY",
"VITE_GDX_HPKE_STATIC_PUBKEY",
"GODARK_EDGE_URL",
"GDX_EDGE_URL",
] {
std::env::remove_var(key);
}
let cfg = GodarkConfigBuilder::new()
.environment(Environment::Devnet)
.api_key_id("id")
.api_secret("secret")
.passphrase("pp")
.build()
.unwrap();
assert_eq!(cfg.base_url, "wss://api.devnet.godark-dex.com");
assert_eq!(
cfg.hpke_static_public_key_hex.as_deref(),
Some(super::DEVNET_HPKE_STATIC_PUBLIC_KEY_HEX)
);
}
#[test]
fn test_builder_localnet_has_no_baked_hpke_pin() {
let _guard = ENV_LOCK.lock().unwrap();
for key in [
"GDX_HPKE_STATIC_PUBLIC_KEY",
"GODARK_EDGE_URL",
"GDX_EDGE_URL",
] {
std::env::remove_var(key);
}
let cfg = GodarkConfigBuilder::new()
.environment(Environment::Localnet)
.api_key_id("id")
.api_secret("secret")
.passphrase("pp")
.build()
.unwrap();
assert_eq!(cfg.base_url, "ws://127.0.0.1:13300");
assert_eq!(cfg.hpke_static_public_key_hex, None);
}
#[test]
fn test_builder_explicit_hpke_pin() {
let cfg = GodarkConfigBuilder::new()
.environment(Environment::Testnet)
.hpke_static_public_key_hex("11".repeat(32))
.api_key_id("id")
.api_secret("secret")
.passphrase("pp")
.build()
.unwrap();
assert_eq!(
cfg.hpke_static_public_key_hex.as_deref(),
Some("1111111111111111111111111111111111111111111111111111111111111111")
);
}
#[test]
fn test_builder_env_hpke_overrides_environment_preset() {
let _guard = ENV_LOCK.lock().unwrap();
for key in [
"GDX_HPKE_STATIC_PUBLIC_KEY",
"GDX_HPKE_STATIC_PUBKEY",
"GODARK_HPKE_STATIC_PUBLIC_KEY",
"VITE_GDX_HPKE_STATIC_PUBKEY",
"GODARK_EDGE_URL",
"GDX_EDGE_URL",
] {
std::env::remove_var(key);
}
let env_pin = "22".repeat(32);
std::env::set_var("GDX_HPKE_STATIC_PUBLIC_KEY", &env_pin);
let cfg = GodarkConfigBuilder::new()
.environment(Environment::Testnet)
.api_key_id("id")
.api_secret("secret")
.passphrase("pp")
.build()
.unwrap();
assert_eq!(
cfg.hpke_static_public_key_hex.as_deref(),
Some(env_pin.as_str())
);
std::env::remove_var("GDX_HPKE_STATIC_PUBLIC_KEY");
}
#[test]
fn test_resolve_edge_base_url_explicit() {
assert_eq!(
resolve_edge_base_url(Some("wss://custom.example")),
"wss://custom.example"
);
}
#[test]
fn test_resolve_edge_base_url_default() {
let _guard = ENV_LOCK.lock().unwrap();
let old_godark = std::env::var("GODARK_EDGE_URL").ok();
let old_gdx = std::env::var("GDX_EDGE_URL").ok();
std::env::remove_var("GODARK_EDGE_URL");
std::env::remove_var("GDX_EDGE_URL");
assert_eq!(resolve_edge_base_url(None), "wss://api.godark-dex.com");
if let Some(v) = old_godark {
std::env::set_var("GODARK_EDGE_URL", v);
}
if let Some(v) = old_gdx {
std::env::set_var("GDX_EDGE_URL", v);
}
}
#[test]
fn test_ws_url_appends_ws() {
assert_eq!(ws_url("wss://example.com"), "wss://example.com/ws/v1");
}
#[test]
fn test_ws_url_no_double_ws() {
assert_eq!(ws_url("wss://example.com/ws"), "wss://example.com/ws/v1");
}
#[test]
fn test_ws_url_idempotent_v1() {
assert_eq!(ws_url("wss://x.com/ws/v1"), "wss://x.com/ws/v1");
}
#[test]
fn test_ws_url_trailing_slash_v1() {
assert_eq!(ws_url("wss://x.com/ws/v1/"), "wss://x.com/ws/v1");
}
#[test]
fn test_gomarket_url_strips_ws() {
assert_eq!(
gomarket_url("wss://example.com/ws"),
"wss://example.com/ws/gomarket"
);
}
#[test]
fn test_gomarket_url_strips_ws_v1() {
assert_eq!(gomarket_url("wss://x.com/ws/v1"), "wss://x.com/ws/gomarket");
}
#[test]
fn test_gomarket_url_plain() {
assert_eq!(
gomarket_url("wss://example.com"),
"wss://example.com/ws/gomarket"
);
}
}