v0.2.10-pre.002-fix.001

crates/ksp-onchain-transport-lib/tests/yellowstone_orbitflare_smoke.rs

@@ -1,9 +1,26 @@
 // file: crates/ksp-onchain-transport-lib/tests/yellowstone_orbitflare_smoke.rs
-// version: 1
+// version: 2
 
-//! Opt-in live OrbitFlare Devnet characterization smoke for provider-neutral Yellowstone gRPC Subscribe.
+//! Opt-in live OrbitFlare Devnet characterization smoke for authenticated provider-neutral Yellowstone gRPC Subscribe.
 
-fn orbitflare_devnet_endpoint() -> ksp_core_lib::Result<ksp_onchain_transport_lib::YellowstoneGrpcEndpointSettings> {
+use std::io::IsTerminal; // rust-rules: trait-import
+
+fn orbitflare_license_x_token() -> std::string::String {
+    assert!(
+        !std::io::stdin().is_terminal(),
+        "pipe the OrbitFlare Solana Free License Key to this ignored smoke on stdin; never pass it as a command-line argument"
+    );
+    let mut token = std::string::String::new();
+    match std::io::stdin().read_line(&mut token) {
+        std::result::Result::Ok(_) => {},
+        std::result::Result::Err(error) => panic!("OrbitFlare License Key x-token must be readable from smoke stdin: {error}"),
+    }
+    let token = token.trim().to_owned();
+    assert!(!token.is_empty(), "OrbitFlare License Key x-token provided on smoke stdin must not be empty");
+    return token;
+}
+
+fn orbitflare_devnet_endpoint(x_token: &str) -> ksp_core_lib::Result<ksp_onchain_transport_lib::YellowstoneGrpcEndpointSettings> {
     let url = match ksp_onchain_transport_lib::YellowstoneGrpcEndpointUrl::parse("http://devnet.rpc.orbitflare.com:10000") {
         std::result::Result::Ok(value) => value,
         std::result::Result::Err(error) => return std::result::Result::Err(error),
@@ -18,14 +35,19 @@ fn orbitflare_devnet_endpoint() -> ksp_core_lib::Result<ksp_onchain_transport_li
         16 * 1024 * 1024,
         4 * 1024 * 1024,
     );
-    return std::result::Result::Ok(ksp_onchain_transport_lib::YellowstoneGrpcEndpointSettings::new(
+    let endpoint = ksp_onchain_transport_lib::YellowstoneGrpcEndpointSettings::new(
         "orbitflare_devnet_yellowstone",
         true,
         ksp_onchain_transport_lib::YellowstoneGrpcProviderName::new("orbitflare"),
         ksp_onchain_transport_lib::YellowstoneGrpcClusterName::new("devnet"),
         url,
         session,
-    ));
+    );
+    let metadata = match ksp_onchain_transport_lib::YellowstoneGrpcMetadataEntry::secret("x-token", x_token) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error),
+    };
+    return endpoint.with_metadata(vec![metadata]);
 }
 
 fn slot_request() -> ksp_core_lib::Result<ksp_onchain_transport_lib::YellowstoneSubscribeRequest> {
@@ -43,22 +65,26 @@ fn slot_request() -> ksp_core_lib::Result<ksp_onchain_transport_lib::Yellowstone
 }
 
 #[tokio::test(flavor = "current_thread")]
-#[ignore = "opt-in live OrbitFlare Devnet Yellowstone gRPC characterization; connects without metadata, waits for Slot plus standard server Ping, then closes"]
-async fn orbitflare_devnet_yellowstone_streams_slots_and_emits_standard_server_ping_without_metadata() {
-    let endpoint = match orbitflare_devnet_endpoint() {
+#[ignore = "opt-in live OrbitFlare Devnet Yellowstone gRPC characterization; reads one Solana Free License Key x-token from stdin, waits for Slot plus standard server Ping, then closes"]
+async fn orbitflare_devnet_yellowstone_streams_slots_and_emits_standard_server_ping_with_license_x_token() {
+    let x_token = orbitflare_license_x_token();
+    let endpoint = match orbitflare_devnet_endpoint(x_token.as_str()) {
         std::result::Result::Ok(value) => value,
-        std::result::Result::Err(error) => panic!("programmatic OrbitFlare Devnet Yellowstone settings must be valid without metadata: {error:?}"),
+        std::result::Result::Err(error) => {
+            panic!("programmatic OrbitFlare Devnet Yellowstone settings must accept the License Key as secret x-token metadata: {error:?}")
+        },
     };
-    assert!(endpoint.metadata().is_empty(), "OrbitFlare Devnet characterization must not invent gRPC metadata");
+    assert_eq!(endpoint.metadata().len(), 1);
+    assert_eq!(endpoint.metadata()[0].key(), "x-token");
+    assert!(endpoint.metadata()[0].is_secret());
     assert!(!endpoint.url().uses_tls(), "the documented OrbitFlare shared Devnet endpoint is intentionally HTTP/2 plaintext");
     let endpoint_debug = format!("{endpoint:?}");
     assert!(!endpoint_debug.contains("orbitflare.com"), "OrbitFlare endpoint URL must not appear in endpoint Debug");
+    assert!(!endpoint_debug.contains(x_token.as_str()), "OrbitFlare License Key x-token must not appear in endpoint Debug");
     assert!(!endpoint_debug.contains("X-ORBIT-KEY"), "OrbitFlare Customer API credentials must not enter Yellowstone settings");
     let channel = match ksp_onchain_transport_lib::YellowstoneGrpcChannel::connect(&endpoint).await {
         std::result::Result::Ok(value) => value,
-        std::result::Result::Err(error) => {
-            panic!("OrbitFlare Devnet Yellowstone connection without metadata must succeed or classify the provider auth gate: {error:?}")
-        },
+        std::result::Result::Err(error) => panic!("OrbitFlare Devnet Yellowstone authenticated connection must succeed: {error:?}"),
     };
     assert_eq!(channel.endpoint_name(), "orbitflare_devnet_yellowstone");
     assert_eq!(channel.provider().as_str(), "orbitflare");
@@ -69,9 +95,7 @@ async fn orbitflare_devnet_yellowstone_streams_slots_and_emits_standard_server_p
     };
     let mut session = match channel.open_standard_subscribe(request).await {
         std::result::Result::Ok(value) => value,
-        std::result::Result::Err(error) => {
-            panic!("OrbitFlare Devnet standard Subscribe without metadata must open or classify the provider auth gate: {error:?}")
-        },
+        std::result::Result::Err(error) => panic!("OrbitFlare Devnet standard Subscribe with License Key x-token must open: {error:?}"),
     };
     let deadline = tokio::time::sleep(std::time::Duration::from_secs(45));
     tokio::pin!(deadline);