// file: crates/ksp-onchain-transport-lib/tests/yellowstone_orbitflare_smoke.rs // version: 2 //! Opt-in live OrbitFlare Devnet characterization smoke for authenticated provider-neutral Yellowstone gRPC Subscribe. 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 { 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), }; let session = ksp_onchain_transport_lib::YellowstoneGrpcSessionSettings::new( std::time::Duration::from_secs(10), std::time::Duration::from_secs(10), std::time::Duration::from_secs(5), ksp_onchain_transport_lib::YellowstoneGrpcReconnectSettings::new(0, std::time::Duration::from_millis(250), std::time::Duration::from_secs(2)), 8, 8, 16 * 1024 * 1024, 4 * 1024 * 1024, ); 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 { let mut request = ksp_onchain_transport_lib::YellowstoneSubscribeRequest::new(); let name = match ksp_onchain_transport_lib::YellowstoneSubscribeFilterName::new("slots") { std::result::Result::Ok(value) => value, std::result::Result::Err(error) => return std::result::Result::Err(error), }; match request.insert_slot_filter(name, ksp_onchain_transport_lib::YellowstoneSubscribeSlotFilter::new()) { std::result::Result::Ok(()) => {}, std::result::Result::Err(error) => return std::result::Result::Err(error), } request.set_commitment(std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Confirmed)); return std::result::Result::Ok(request); } #[tokio::test(flavor = "current_thread")] #[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 accept the License Key as secret x-token metadata: {error:?}") }, }; 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 authenticated connection must succeed: {error:?}"), }; assert_eq!(channel.endpoint_name(), "orbitflare_devnet_yellowstone"); assert_eq!(channel.provider().as_str(), "orbitflare"); assert_eq!(channel.cluster().as_str(), "devnet"); let request = match slot_request() { std::result::Result::Ok(value) => value, std::result::Result::Err(error) => panic!("OrbitFlare Yellowstone slot request must be valid: {error:?}"), }; 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 with License Key x-token must open: {error:?}"), }; let deadline = tokio::time::sleep(std::time::Duration::from_secs(45)); tokio::pin!(deadline); let mut slot_seen = false; let mut ping_seen = false; loop { tokio::select! { () = &mut deadline => break, next_update = session.next_update() => { let next_update = match next_update { std::result::Result::Ok(value) => value, std::result::Result::Err(error) => panic!("OrbitFlare Devnet Yellowstone Subscribe update must decode: {error:?}"), }; match next_update { std::option::Option::Some(ksp_onchain_transport_lib::YellowstoneSubscribeUpdate::Slot(update)) => { if update.slot() > 0 { slot_seen = true; } }, std::option::Option::Some(ksp_onchain_transport_lib::YellowstoneSubscribeUpdate::Ping(_)) => ping_seen = true, std::option::Option::Some(_) => {}, std::option::Option::None => break, } if slot_seen && ping_seen { break; } }, } } let close_timeout_result = tokio::time::timeout(std::time::Duration::from_secs(7), session.close()).await; let close_result = match close_timeout_result { std::result::Result::Ok(value) => value, std::result::Result::Err(error) => { panic!("KSP Yellowstone Subscribe close must remain bounded beyond the configured five-second provider half-close deadline: {error}") }, }; match close_result { std::result::Result::Ok(()) => {}, std::result::Result::Err(error) => { assert_eq!( error.code(), ksp_onchain_transport_lib::ERROR_CODE_TIMEOUT, "after live characterization, OrbitFlare close may time out waiting for provider half-close but must not fail for another reason: {error:?}" ); }, } assert!(slot_seen, "OrbitFlare Devnet Yellowstone must publish at least one non-zero confirmed slot during the 45-second characterization window"); assert!( ping_seen, "OrbitFlare Devnet must emit the standard Yellowstone server Ping during the 45-second characterization window before any provider-specific heartbeat is justified" ); }