v0.2.9-pre.013-fix.001

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

@@ -1,10 +1,10 @@
 // file: crates/ksp-onchain-transport-lib/tests/yellowstone_publicnode_smoke.rs
-// version: 1
+// version: 2
 
-//! Opt-in live PublicNode Mainnet smoke for the provider-neutral Yellowstone gRPC facade.
+//! Opt-in live PublicNode Mainnet/Testnet smokes for the provider-neutral Yellowstone gRPC Subscribe facade.
 
-fn publicnode_mainnet_endpoint() -> ksp_core_lib::Result<ksp_onchain_transport_lib::YellowstoneGrpcEndpointSettings> {
-    let url = match ksp_onchain_transport_lib::YellowstoneGrpcEndpointUrl::parse("https://solana-yellowstone-grpc.publicnode.com:443") {
+fn publicnode_endpoint(name: &str, cluster: &str, url: &str) -> ksp_core_lib::Result<ksp_onchain_transport_lib::YellowstoneGrpcEndpointSettings> {
+    let url = match ksp_onchain_transport_lib::YellowstoneGrpcEndpointUrl::parse(url) {
         std::result::Result::Ok(value) => value,
         std::result::Result::Err(error) => return std::result::Result::Err(error),
     };
@@ -19,29 +19,56 @@ fn publicnode_mainnet_endpoint() -> ksp_core_lib::Result<ksp_onchain_transport_l
         4 * 1024 * 1024,
     );
     return std::result::Result::Ok(ksp_onchain_transport_lib::YellowstoneGrpcEndpointSettings::new(
-        "publicnode_mainnet_yellowstone",
+        name,
         true,
         ksp_onchain_transport_lib::YellowstoneGrpcProviderName::new("publicnode"),
-        ksp_onchain_transport_lib::YellowstoneGrpcClusterName::new("mainnet-beta"),
+        ksp_onchain_transport_lib::YellowstoneGrpcClusterName::new(cluster),
         url,
         session,
     ));
 }
 
-#[tokio::test(flavor = "current_thread")]
-#[ignore = "opt-in live PublicNode Mainnet Yellowstone gRPC smoke; performs external TLS and unary gRPC requests"]
-async fn publicnode_mainnet_yellowstone_reaches_standard_version_and_slot_without_credentials() {
-    let endpoint = publicnode_mainnet_endpoint().expect("programmatic PublicNode Yellowstone settings must construct an endpoint");
-    let channel = ksp_onchain_transport_lib::YellowstoneGrpcChannel::connect(&endpoint).await.expect("PublicNode Yellowstone TLS connection must succeed");
-    assert_eq!(channel.endpoint_name(), "publicnode_mainnet_yellowstone");
-    assert_eq!(channel.provider().as_str(), "publicnode");
-    assert_eq!(channel.cluster().as_str(), "mainnet-beta");
-    let client = channel.standard_unary_client();
-    let version = client.get_version().await.expect("PublicNode Yellowstone GetVersion must succeed");
-    assert!(!version.version().is_empty());
-    let slot = client
-        .get_slot(std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Confirmed))
-        .await
-        .expect("PublicNode Yellowstone GetSlot must succeed");
-    assert!(slot.slot() > 0);
+fn slot_request() -> ksp_core_lib::Result<ksp_onchain_transport_lib::YellowstoneSubscribeRequest> {
+    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),
+    };
+    request.insert_slot_filter(name, ksp_onchain_transport_lib::YellowstoneSubscribeSlotFilter::new())?;
+    return std::result::Result::Ok(request);
+}
+
+async fn assert_publicnode_slot_stream(name: &str, cluster: &str, url: &str) {
+    let endpoint = publicnode_endpoint(name, cluster, url).expect("programmatic PublicNode Yellowstone settings must construct an unauthenticated endpoint");
+    let channel = ksp_onchain_transport_lib::YellowstoneGrpcChannel::connect(&endpoint).await.expect("PublicNode Yellowstone TLS connection must succeed");
+    assert_eq!(channel.endpoint_name(), name);
+    assert_eq!(channel.provider().as_str(), "publicnode");
+    assert_eq!(channel.cluster().as_str(), cluster);
+    let request = slot_request().expect("PublicNode Yellowstone slot request must be valid");
+    let mut session = channel.open_standard_subscribe(request).await.expect("PublicNode Yellowstone Subscribe must open without authentication metadata");
+    let slot = tokio::time::timeout(std::time::Duration::from_secs(20), async {
+        loop {
+            match session.next_update().await.expect("PublicNode Yellowstone Subscribe update must decode") {
+                std::option::Option::Some(ksp_onchain_transport_lib::YellowstoneSubscribeUpdate::Slot(update)) => break update.slot(),
+                std::option::Option::Some(_) => {},
+                std::option::Option::None => panic!("PublicNode Yellowstone Subscribe ended before a slot update"),
+            }
+        }
+    })
+    .await
+    .expect("PublicNode Yellowstone Subscribe must publish a slot update before the smoke deadline");
+    assert!(slot > 0);
+    session.close().await.expect("PublicNode Yellowstone Subscribe must close cleanly");
+}
+
+#[tokio::test(flavor = "current_thread")]
+#[ignore = "opt-in live PublicNode Mainnet Yellowstone gRPC smoke; performs an unauthenticated external TLS/Subscribe request"]
+async fn publicnode_mainnet_yellowstone_streams_slots_without_authentication_metadata() {
+    assert_publicnode_slot_stream("publicnode_mainnet_yellowstone", "mainnet-beta", "https://solana-yellowstone-grpc.publicnode.com:443").await;
+}
+
+#[tokio::test(flavor = "current_thread")]
+#[ignore = "opt-in live PublicNode Testnet Yellowstone gRPC smoke; performs an unauthenticated external TLS/Subscribe request"]
+async fn publicnode_testnet_yellowstone_streams_slots_without_authentication_metadata() {
+    assert_publicnode_slot_stream("publicnode_testnet_yellowstone", "testnet", "https://solana-testnet-yellowstone-grpc.publicnode.com:443").await;
 }