v0.2.11-pre.005

crates/ksp-offchain-transport-lib/src/lib.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-offchain-transport-lib/src/lib.rs
-// version: 6
+// version: 7
 
 #![warn(missing_docs)]
 #![deny(unreachable_pub)]
@@ -7,10 +7,10 @@
 
 //! KSP-owned off-chain transport foundation.
 //!
-//! `0.2.11-pre.004` keeps the first capability family deliberately narrow (`market_price`, SOL/USD only), activates the crate-wide hardened `http_*`
-//! primitives in production, and introduces the first three direct-REST adapters: CoinGecko, CoinMarketCap and CoinPaprika. Provider wire DTOs remain
-//! private, no provider SDK is used, and the `http_*` internals are not re-exported as a generic consumer HTTP client. Config integration and generic
-//! registry/refresh orchestration remain outside this tranche.
+//! `0.2.11-pre.005` keeps the first capability family deliberately narrow (`market_price`, SOL/USD only) and extends the direct-REST surface with
+//! Kraken Spot and Coinbase Exchange. Exchange adapters preserve `ExchangeLastTrade` semantics instead of pretending to be aggregated market prices.
+//! Provider wire DTOs remain private, no provider SDK is used, and the crate-wide hardened `http_*` internals remain unavailable as a generic consumer
+//! HTTP client. Config integration and generic registry/refresh orchestration remain outside this tranche.
 
 mod constants;
 mod error;
@@ -19,10 +19,12 @@ mod http_client;
 mod http_settings;
 mod market_price_adapter;
 mod market_price_api_key;
+mod market_price_coinbase_exchange;
 mod market_price_coingecko;
 mod market_price_coinmarketcap;
 mod market_price_coinpaprika;
 mod market_price_decimal;
+mod market_price_kraken;
 mod market_price_observation;
 mod market_price_provider;
 mod market_price_settings;
@@ -67,6 +69,10 @@ pub use self::error::ERROR_CODE_MARKET_PRICE_PROVIDER_ID_INVALID;
 pub use self::error::ERROR_CODE_MARKET_PRICE_PROVIDER_RESPONSE_INVALID;
 /// Stable error code for invalid common provider settings.
 pub use self::error::ERROR_CODE_MARKET_PRICE_PROVIDER_SETTINGS_INVALID;
+/// Coinbase Exchange SOL/USD provider adapter.
+pub use self::market_price_coinbase_exchange::MarketPriceCoinbaseExchangeProvider;
+/// Coinbase Exchange runtime settings.
+pub use self::market_price_coinbase_exchange::MarketPriceCoinbaseExchangeSettings;
 /// CoinGecko V1 access mode.
 pub use self::market_price_coingecko::MarketPriceCoinGeckoAccessMode;
 /// CoinGecko SOL/USD provider adapter.
@@ -89,6 +95,10 @@ pub use self::market_price_decimal::MARKET_PRICE_DECIMAL_MAX_INPUT_BYTES;
 pub use self::market_price_decimal::MARKET_PRICE_DECIMAL_MAX_SCALE;
 /// Exact positive decimal value used by the public market-price contract.
 pub use self::market_price_decimal::MarketPriceDecimal;
+/// Kraken Spot SOL/USD provider adapter.
+pub use self::market_price_kraken::MarketPriceKrakenProvider;
+/// Kraken Spot runtime settings.
+pub use self::market_price_kraken::MarketPriceKrakenSettings;
 /// Maximum safe provenance length attached to one normalized observation.
 pub use self::market_price_observation::MARKET_PRICE_PROVENANCE_MAX_BYTES;
 /// Public V1 SOL/USD observation normalized by Off-chain Transport.

crates/ksp-offchain-transport-lib/src/market_price_coinbase_exchange.rs

@@ -0,0 +1,159 @@
+// file: crates/ksp-offchain-transport-lib/src/market_price_coinbase_exchange.rs
+// version: 1
+
+//! Coinbase Exchange SOL/USD market-price adapter using the public product ticker directly through `reqwest`.
+
+const COINBASE_EXCHANGE_PROVIDER_ID: &str = "coinbase_exchange";
+const COINBASE_EXCHANGE_SOL_USD_TICKER_URL: &str = "https://api.exchange.coinbase.com/products/SOL-USD/ticker";
+
+/// Runtime settings for the keyless Coinbase Exchange market-price adapter.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct MarketPriceCoinbaseExchangeSettings {
+    common: crate::MarketPriceProviderCommonSettings,
+}
+
+impl crate::MarketPriceCoinbaseExchangeSettings {
+    /// Creates Coinbase Exchange settings for the public keyless REST surface.
+    pub fn new(enabled: bool) -> ksp_core_lib::Result<Self> {
+        let provider_id = match crate::MarketPriceProviderId::new(COINBASE_EXCHANGE_PROVIDER_ID) {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        return std::result::Result::Ok(Self { common: crate::MarketPriceProviderCommonSettings::new(provider_id, enabled) });
+    }
+
+    /// Returns common provider identity and enablement settings.
+    #[must_use]
+    pub const fn common(&self) -> &crate::MarketPriceProviderCommonSettings {
+        return &self.common;
+    }
+}
+
+/// Coinbase Exchange SOL/USD provider adapter.
+pub struct MarketPriceCoinbaseExchangeProvider {
+    admission: crate::HttpAdmissionController,
+    descriptor: crate::MarketPriceProviderDescriptor,
+    http: crate::HttpRestClient,
+    settings: crate::MarketPriceCoinbaseExchangeSettings,
+}
+
+impl crate::MarketPriceCoinbaseExchangeProvider {
+    /// Builds one Coinbase Exchange provider from validated runtime settings.
+    pub fn new(settings: crate::MarketPriceCoinbaseExchangeSettings) -> ksp_core_lib::Result<Self> {
+        let descriptor = match descriptor_for(settings.common().provider_id().clone()) {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        let runtime = match crate::provider_http_runtime(descriptor.rate_limit()) {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        return std::result::Result::Ok(Self { admission: runtime.1, descriptor, http: runtime.0, settings });
+    }
+
+    /// Returns the provider-neutral Coinbase Exchange capability descriptor.
+    #[must_use]
+    pub const fn descriptor(&self) -> &crate::MarketPriceProviderDescriptor {
+        return &self.descriptor;
+    }
+
+    /// Returns the validated Coinbase Exchange runtime settings.
+    #[must_use]
+    pub const fn settings(&self) -> &crate::MarketPriceCoinbaseExchangeSettings {
+        return &self.settings;
+    }
+
+    /// Fetches one normalized SOL/USD last-trade observation from Coinbase Exchange.
+    pub async fn fetch_sol_usd(&self) -> ksp_core_lib::Result<crate::MarketPriceObservation> {
+        if !self.settings.common().enabled() {
+            return std::result::Result::Err(crate::provider_disabled_error(COINBASE_EXCHANGE_PROVIDER_ID));
+        }
+        if let std::result::Result::Err(error) = crate::admit_request(COINBASE_EXCHANGE_PROVIDER_ID, &self.admission) {
+            return std::result::Result::Err(error);
+        }
+        let request_started_at = match crate::current_timestamp() {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        let request = match build_request() {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        let document = match crate::get_json(&self.http, &self.admission, COINBASE_EXCHANGE_PROVIDER_ID, request).await {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        let received_at = match crate::current_timestamp() {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        return parse_response(document.as_bytes(), self.settings.common().provider_id().clone(), request_started_at, received_at);
+    }
+}
+
+fn build_request() -> ksp_core_lib::Result<crate::HttpGetRequest> {
+    return crate::HttpGetRequest::new_https(COINBASE_EXCHANGE_SOL_USD_TICKER_URL);
+}
+
+fn descriptor_for(provider_id: crate::MarketPriceProviderId) -> ksp_core_lib::Result<crate::MarketPriceProviderDescriptor> {
+    let rate_limit = match crate::MarketPriceProviderRateLimit::fixed(10, 1, std::option::Option::Some(15), crate::MarketPriceProviderRateLimitScope::Ip) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    return crate::MarketPriceProviderDescriptor::new(
+        provider_id,
+        "Coinbase Exchange",
+        crate::MarketPriceSemantics::ExchangeLastTrade,
+        crate::MarketPriceProviderAuthMode::None,
+        rate_limit,
+        std::option::Option::None,
+        true,
+    );
+}
+
+fn parse_response(
+    bytes: &[u8],
+    provider_id: crate::MarketPriceProviderId,
+    request_started_at: crate::MarketPriceTimestamp,
+    received_at: crate::MarketPriceTimestamp,
+) -> ksp_core_lib::Result<crate::MarketPriceObservation> {
+    let wire = match serde_json::from_slice::<CoinbaseExchangeWireTicker>(bytes) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => {
+            return std::result::Result::Err(crate::invalid_provider_response_with_source(COINBASE_EXCHANGE_PROVIDER_ID, "response", error));
+        },
+    };
+    let price = match crate::MarketPriceDecimal::parse_json_raw(wire.price.as_ref()) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let provider_timestamp = match crate::market_price_timestamp_from_rfc3339(wire.time.as_str()) {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => {
+            return std::result::Result::Err(crate::invalid_provider_response(COINBASE_EXCHANGE_PROVIDER_ID, "time"));
+        },
+    };
+    let provenance = match crate::MarketPriceProvenance::new("coinbase_exchange:SOL-USD:last_trade") {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    return crate::MarketPriceObservation::new(
+        provider_id,
+        price,
+        crate::MarketPriceSemantics::ExchangeLastTrade,
+        request_started_at,
+        received_at,
+        std::option::Option::Some(provider_timestamp),
+        provenance,
+    );
+}
+
+#[derive(serde::Deserialize)]
+struct CoinbaseExchangeWireTicker {
+    price: std::boxed::Box<serde_json::value::RawValue>,
+    time: std::string::String,
+}
+
+#[cfg(test)]
+#[path = "../unit_tests/market_price_coinbase_exchange.rs"]
+mod tests;

crates/ksp-offchain-transport-lib/src/market_price_kraken.rs

@@ -0,0 +1,179 @@
+// file: crates/ksp-offchain-transport-lib/src/market_price_kraken.rs
+// version: 1
+
+//! Kraken Spot SOL/USD market-price adapter using the public REST ticker directly through `reqwest`.
+
+const KRAKEN_PROVIDER_ID: &str = "kraken";
+const KRAKEN_SOL_USD_PAIR: &str = "SOLUSD";
+const KRAKEN_TICKER_URL: &str = "https://api.kraken.com/0/public/Ticker";
+
+/// Runtime settings for the keyless Kraken Spot market-price adapter.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct MarketPriceKrakenSettings {
+    common: crate::MarketPriceProviderCommonSettings,
+}
+
+impl crate::MarketPriceKrakenSettings {
+    /// Creates Kraken Spot settings for the public keyless REST surface.
+    pub fn new(enabled: bool) -> ksp_core_lib::Result<Self> {
+        let provider_id = match crate::MarketPriceProviderId::new(KRAKEN_PROVIDER_ID) {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        return std::result::Result::Ok(Self { common: crate::MarketPriceProviderCommonSettings::new(provider_id, enabled) });
+    }
+
+    /// Returns common provider identity and enablement settings.
+    #[must_use]
+    pub const fn common(&self) -> &crate::MarketPriceProviderCommonSettings {
+        return &self.common;
+    }
+}
+
+/// Kraken Spot SOL/USD provider adapter.
+pub struct MarketPriceKrakenProvider {
+    admission: crate::HttpAdmissionController,
+    descriptor: crate::MarketPriceProviderDescriptor,
+    http: crate::HttpRestClient,
+    settings: crate::MarketPriceKrakenSettings,
+}
+
+impl crate::MarketPriceKrakenProvider {
+    /// Builds one Kraken Spot provider from validated runtime settings.
+    pub fn new(settings: crate::MarketPriceKrakenSettings) -> ksp_core_lib::Result<Self> {
+        let descriptor = match descriptor_for(settings.common().provider_id().clone()) {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        let runtime = match crate::provider_http_runtime(descriptor.rate_limit()) {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        return std::result::Result::Ok(Self { admission: runtime.1, descriptor, http: runtime.0, settings });
+    }
+
+    /// Returns the provider-neutral Kraken Spot capability descriptor.
+    #[must_use]
+    pub const fn descriptor(&self) -> &crate::MarketPriceProviderDescriptor {
+        return &self.descriptor;
+    }
+
+    /// Returns the validated Kraken Spot runtime settings.
+    #[must_use]
+    pub const fn settings(&self) -> &crate::MarketPriceKrakenSettings {
+        return &self.settings;
+    }
+
+    /// Fetches one normalized SOL/USD last-trade observation from Kraken Spot.
+    pub async fn fetch_sol_usd(&self) -> ksp_core_lib::Result<crate::MarketPriceObservation> {
+        if !self.settings.common().enabled() {
+            return std::result::Result::Err(crate::provider_disabled_error(KRAKEN_PROVIDER_ID));
+        }
+        if let std::result::Result::Err(error) = crate::admit_request(KRAKEN_PROVIDER_ID, &self.admission) {
+            return std::result::Result::Err(error);
+        }
+        let request_started_at = match crate::current_timestamp() {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        let request = match build_request() {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        let document = match crate::get_json(&self.http, &self.admission, KRAKEN_PROVIDER_ID, request).await {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        let received_at = match crate::current_timestamp() {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        return parse_response(document.as_bytes(), self.settings.common().provider_id().clone(), request_started_at, received_at);
+    }
+}
+
+fn build_request() -> ksp_core_lib::Result<crate::HttpGetRequest> {
+    let mut request = match crate::HttpGetRequest::new_https(KRAKEN_TICKER_URL) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    request.append_query_pair("pair", KRAKEN_SOL_USD_PAIR);
+    return std::result::Result::Ok(request);
+}
+
+fn descriptor_for(provider_id: crate::MarketPriceProviderId) -> ksp_core_lib::Result<crate::MarketPriceProviderDescriptor> {
+    let rate_limit = match crate::MarketPriceProviderRateLimit::fixed(1, 1, std::option::Option::None, crate::MarketPriceProviderRateLimitScope::Ip) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    return crate::MarketPriceProviderDescriptor::new(
+        provider_id,
+        "Kraken",
+        crate::MarketPriceSemantics::ExchangeLastTrade,
+        crate::MarketPriceProviderAuthMode::None,
+        rate_limit,
+        std::option::Option::None,
+        true,
+    );
+}
+
+fn parse_response(
+    bytes: &[u8],
+    provider_id: crate::MarketPriceProviderId,
+    request_started_at: crate::MarketPriceTimestamp,
+    received_at: crate::MarketPriceTimestamp,
+) -> ksp_core_lib::Result<crate::MarketPriceObservation> {
+    let wire = match serde_json::from_slice::<KrakenWireResponse>(bytes) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => {
+            return std::result::Result::Err(crate::invalid_provider_response_with_source(KRAKEN_PROVIDER_ID, "response", error));
+        },
+    };
+    if !wire.error.is_empty() {
+        return std::result::Result::Err(crate::invalid_provider_response(KRAKEN_PROVIDER_ID, "error"));
+    }
+    if wire.result.len() != 1 {
+        return std::result::Result::Err(crate::invalid_provider_response(KRAKEN_PROVIDER_ID, "result"));
+    }
+    let ticker = match wire.result.get(KRAKEN_SOL_USD_PAIR) {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return std::result::Result::Err(crate::invalid_provider_response(KRAKEN_PROVIDER_ID, "identity")),
+    };
+    let last_trade = match ticker.last_trade.first() {
+        std::option::Option::Some(value) => value,
+        std::option::Option::None => return std::result::Result::Err(crate::invalid_provider_response(KRAKEN_PROVIDER_ID, "last_trade")),
+    };
+    let price = match crate::MarketPriceDecimal::parse_json_raw(last_trade.as_ref()) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let provenance = match crate::MarketPriceProvenance::new("kraken:SOLUSD:last_trade") {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    return crate::MarketPriceObservation::new(
+        provider_id,
+        price,
+        crate::MarketPriceSemantics::ExchangeLastTrade,
+        request_started_at,
+        received_at,
+        std::option::Option::None,
+        provenance,
+    );
+}
+
+#[derive(serde::Deserialize)]
+struct KrakenWireResponse {
+    error: std::vec::Vec<std::string::String>,
+    result: std::collections::BTreeMap<std::string::String, KrakenWireTicker>,
+}
+
+#[derive(serde::Deserialize)]
+struct KrakenWireTicker {
+    #[serde(rename = "c")]
+    last_trade: std::vec::Vec<std::boxed::Box<serde_json::value::RawValue>>,
+}
+
+#[cfg(test)]
+#[path = "../unit_tests/market_price_kraken.rs"]
+mod tests;