v0.2.11-pre.010

crates/ksp-offchain-transport-lib/tests/release_completeness.rs

@@ -0,0 +1,161 @@
+// file: crates/ksp-offchain-transport-lib/tests/release_completeness.rs
+// version: 1
+
+#![warn(missing_docs)]
+#![deny(unreachable_pub)]
+#![forbid(unsafe_code)]
+
+//! Release-level completeness canaries for the eight-provider SOL/USD V1 contract.
+
+#[test]
+fn pre_010_exact_eight_provider_inventory_and_semantics_are_stable() -> ksp_core_lib::Result<()> {
+    let setups = match all_disabled_setups() {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let service = match ksp_offchain_transport_lib::MarketPriceService::new(setups) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let registry = service.registry();
+    assert_eq!(registry.len(), 8);
+    let expected = [
+        (
+            "birdeye",
+            ksp_offchain_transport_lib::MarketPriceSemantics::SolanaSpot,
+            ksp_offchain_transport_lib::MarketPriceProviderAuthMode::RequiredApiKey,
+        ),
+        (
+            "coinbase_exchange",
+            ksp_offchain_transport_lib::MarketPriceSemantics::ExchangeLastTrade,
+            ksp_offchain_transport_lib::MarketPriceProviderAuthMode::None,
+        ),
+        (
+            "coingecko",
+            ksp_offchain_transport_lib::MarketPriceSemantics::AggregatedMarket,
+            ksp_offchain_transport_lib::MarketPriceProviderAuthMode::None,
+        ),
+        (
+            "coinmarketcap",
+            ksp_offchain_transport_lib::MarketPriceSemantics::AggregatedMarket,
+            ksp_offchain_transport_lib::MarketPriceProviderAuthMode::None,
+        ),
+        (
+            "coinpaprika",
+            ksp_offchain_transport_lib::MarketPriceSemantics::AggregatedMarket,
+            ksp_offchain_transport_lib::MarketPriceProviderAuthMode::None,
+        ),
+        ("dexscreener", ksp_offchain_transport_lib::MarketPriceSemantics::DexPairUsd, ksp_offchain_transport_lib::MarketPriceProviderAuthMode::None),
+        ("jupiter", ksp_offchain_transport_lib::MarketPriceSemantics::SolanaHeuristic, ksp_offchain_transport_lib::MarketPriceProviderAuthMode::None),
+        ("kraken", ksp_offchain_transport_lib::MarketPriceSemantics::ExchangeLastTrade, ksp_offchain_transport_lib::MarketPriceProviderAuthMode::None),
+    ];
+    for (entry, (provider_id, semantics, auth_mode)) in registry.entries().iter().zip(expected) {
+        assert_eq!(entry.descriptor().id().as_str(), provider_id);
+        assert_eq!(entry.descriptor().semantics(), semantics);
+        assert_eq!(entry.descriptor().auth_mode(), auth_mode);
+        assert!(entry.descriptor().supports_sol_usd());
+        assert_eq!(entry.state().availability(), ksp_offchain_transport_lib::MarketPriceProviderAvailability::Disabled);
+    }
+    return std::result::Result::Ok(());
+}
+
+#[test]
+fn pre_010_evolutive_public_enums_are_non_exhaustive() -> std::io::Result<()> {
+    let root = crate_root();
+    let provider = match std::fs::read_to_string(root.join("src/market_price_provider.rs")) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    for enum_name in [
+        "MarketPricePair",
+        "MarketPriceSemantics",
+        "MarketPriceProviderAuthMode",
+        "MarketPriceProviderRateLimitScope",
+        "MarketPriceProviderRateLimitKind",
+        "MarketPriceProviderQuotaPeriod",
+        "MarketPriceProviderQuotaUnit",
+        "MarketPriceProviderAvailability",
+    ] {
+        assert_non_exhaustive(provider.as_str(), enum_name);
+    }
+    let coingecko = match std::fs::read_to_string(root.join("src/market_price_coingecko.rs")) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    assert_non_exhaustive(coingecko.as_str(), "MarketPriceCoinGeckoAccessMode");
+    let coinmarketcap = match std::fs::read_to_string(root.join("src/market_price_coinmarketcap.rs")) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    assert_non_exhaustive(coinmarketcap.as_str(), "MarketPriceCoinMarketCapAccessMode");
+    let jupiter = match std::fs::read_to_string(root.join("src/market_price_jupiter.rs")) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    assert_non_exhaustive(jupiter.as_str(), "MarketPriceJupiterAccessMode");
+    let service = match std::fs::read_to_string(root.join("src/market_price_service.rs")) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    assert_non_exhaustive(service.as_str(), "MarketPriceProviderSetup");
+    return std::result::Result::Ok(());
+}
+
+fn all_disabled_setups() -> ksp_core_lib::Result<std::vec::Vec<ksp_offchain_transport_lib::MarketPriceProviderSetup>> {
+    let birdeye = match ksp_offchain_transport_lib::MarketPriceBirdeyeSettings::new(false, std::option::Option::None) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let coinbase = match ksp_offchain_transport_lib::MarketPriceCoinbaseExchangeSettings::new(false) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let coingecko = match ksp_offchain_transport_lib::MarketPriceCoinGeckoSettings::keyless(false) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let coinmarketcap = match ksp_offchain_transport_lib::MarketPriceCoinMarketCapSettings::keyless(false) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let coinpaprika = match ksp_offchain_transport_lib::MarketPriceCoinPaprikaSettings::new(false) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let dexscreener = match ksp_offchain_transport_lib::MarketPriceDexScreenerSettings::new(false, std::option::Option::None) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let jupiter = match ksp_offchain_transport_lib::MarketPriceJupiterSettings::keyless(false) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let kraken = match ksp_offchain_transport_lib::MarketPriceKrakenSettings::new(false) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    return std::result::Result::Ok(std::vec![
+        ksp_offchain_transport_lib::MarketPriceProviderSetup::Birdeye(birdeye),
+        ksp_offchain_transport_lib::MarketPriceProviderSetup::CoinbaseExchange(coinbase),
+        ksp_offchain_transport_lib::MarketPriceProviderSetup::CoinGecko(coingecko),
+        ksp_offchain_transport_lib::MarketPriceProviderSetup::CoinMarketCap(coinmarketcap),
+        ksp_offchain_transport_lib::MarketPriceProviderSetup::CoinPaprika(coinpaprika),
+        ksp_offchain_transport_lib::MarketPriceProviderSetup::DexScreener(dexscreener),
+        ksp_offchain_transport_lib::MarketPriceProviderSetup::Jupiter(jupiter),
+        ksp_offchain_transport_lib::MarketPriceProviderSetup::Kraken(kraken),
+    ]);
+}
+
+fn assert_non_exhaustive(source: &str, enum_name: &str) {
+    let marker = std::format!("pub enum {enum_name}");
+    let position = source.find(marker.as_str());
+    assert!(position.is_some(), "public enum must remain present: {enum_name}");
+    if let std::option::Option::Some(position) = position {
+        let start = position.saturating_sub(256);
+        assert!(source[start..position].contains("#[non_exhaustive]"), "evolutive public enum must be non_exhaustive: {enum_name}");
+    }
+}
+
+fn crate_root() -> std::path::PathBuf {
+    return std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+}

crates/ksp-offchain-transport-lib/tests/security_hardening.rs

@@ -0,0 +1,90 @@
+// file: crates/ksp-offchain-transport-lib/tests/security_hardening.rs
+// version: 1
+
+#![warn(missing_docs)]
+#![deny(unreachable_pub)]
+#![forbid(unsafe_code)]
+
+//! Adversarial security canaries for Off-chain Transport diagnostics, credentials and ownership boundaries.
+
+#[test]
+fn pre_010_keyed_settings_and_service_debug_never_expose_credentials() -> ksp_core_lib::Result<()> {
+    let secret = "pre010-api-key-secret-canary";
+    let birdeye = match ksp_offchain_transport_lib::MarketPriceBirdeyeSettings::new(true, std::option::Option::Some(secret.to_owned())) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let coingecko = match ksp_offchain_transport_lib::MarketPriceCoinGeckoSettings::demo(true, std::option::Option::Some(secret.to_owned())) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let coinmarketcap = match ksp_offchain_transport_lib::MarketPriceCoinMarketCapSettings::basic(true, std::option::Option::Some(secret.to_owned())) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    let jupiter = match ksp_offchain_transport_lib::MarketPriceJupiterSettings::free(true, std::option::Option::Some(secret.to_owned())) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    for debug in [std::format!("{birdeye:?}"), std::format!("{coingecko:?}"), std::format!("{coinmarketcap:?}"), std::format!("{jupiter:?}")] {
+        assert!(!debug.contains(secret));
+        assert!(debug.contains("api_key_present"));
+    }
+    let service = match ksp_offchain_transport_lib::MarketPriceService::new(std::vec![
+        ksp_offchain_transport_lib::MarketPriceProviderSetup::Birdeye(birdeye),
+        ksp_offchain_transport_lib::MarketPriceProviderSetup::CoinGecko(coingecko),
+        ksp_offchain_transport_lib::MarketPriceProviderSetup::CoinMarketCap(coinmarketcap),
+        ksp_offchain_transport_lib::MarketPriceProviderSetup::Jupiter(jupiter),
+    ]) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    assert!(!std::format!("{service:?}").contains(secret));
+    return std::result::Result::Ok(());
+}
+
+#[test]
+fn pre_010_market_price_sources_do_not_read_environment_or_use_float_price_truth() -> std::io::Result<()> {
+    let src = crate_root().join("src");
+    let entries = match std::fs::read_dir(src) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    for entry in entries {
+        let entry = match entry {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        let name = entry.file_name();
+        let name = name.to_string_lossy();
+        if !name.starts_with("market_price_") || !name.ends_with(".rs") {
+            continue;
+        }
+        let source = match std::fs::read_to_string(entry.path()) {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        assert!(!source.contains("std::env"), "market-price source must not bypass Config environment ownership: {name}");
+        assert!(!source.contains("as_f64("), "market-price source must not use serde_json f64 as canonical price truth: {name}");
+        assert!(!source.contains("tracing::"), "market-price source must use ksp-logging-lib rather than tracing directly: {name}");
+    }
+    return std::result::Result::Ok(());
+}
+
+#[test]
+fn pre_010_config_schema_exposes_no_provider_url_or_rate_limit_override() -> std::io::Result<()> {
+    let root = crate_root().join("../..");
+    let schema = match std::fs::read_to_string(root.join("config/schemas/std.offchain_transport.schema.json")) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    assert!(!schema.contains("base_url"));
+    assert!(!schema.contains("endpoint_url"));
+    assert!(!schema.contains("rate_limit"));
+    assert!(!schema.contains("requests_per"));
+    return std::result::Result::Ok(());
+}
+
+fn crate_root() -> std::path::PathBuf {
+    return std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+}