v0.2.8-pre.005-fix.001

crates/ksp-onchain-transport-lib/unit_tests/ws_helius_transactions.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-onchain-transport-lib/unit_tests/ws_helius_transactions.rs
-// version: 2
+// version: 3
 
 use futures_util::SinkExt; // rust-rules: trait-import
 use futures_util::StreamExt; // rust-rules: trait-import
@@ -91,11 +91,11 @@ fn helius_transaction_subscribe_request_serializes_complete_documented_filter_an
         std::option::Option::Some(0),
     );
     let request = crate::HeliusTransactionSubscribeRequest::new(filter, std::option::Option::Some(options));
-    let params = request.to_params().expect("complete documented Helius request must validate");
+    let params = super::helius_transaction_subscribe_params(&request).expect("complete documented Helius request must validate");
     assert_eq!(
         params,
-        serde_json::json!([
-            {
+        std::vec![
+            serde_json::json!({
                 "vote": false,
                 "failed": false,
                 "signature": "fixture-signature-secret-canary",
@@ -103,15 +103,15 @@ fn helius_transaction_subscribe_request_serializes_complete_documented_filter_an
                 "accountExclude": ["SysvarC1ock11111111111111111111111111111111"],
                 "accountRequired": ["Vote111111111111111111111111111111111111111"],
                 "tokenAccounts": "balanceChanged"
-            },
-            {
+            }),
+            serde_json::json!({
                 "commitment": "confirmed",
                 "encoding": "jsonParsed",
                 "transactionDetails": "accounts",
                 "showRewards": true,
                 "maxSupportedTransactionVersion": 0
-            }
-        ])
+            })
+        ]
     );
     assert_eq!(request.filter().vote(), std::option::Option::Some(false));
     assert_eq!(request.filter().failed(), std::option::Option::Some(false));
@@ -131,7 +131,10 @@ fn helius_transaction_subscribe_request_serializes_complete_documented_filter_an
 #[test]
 fn helius_transaction_request_preserves_omitted_explicit_empty_and_explicit_none_states() {
     let omitted = crate::HeliusTransactionSubscribeRequest::new(crate::HeliusTransactionSubscribeFilter::default(), std::option::Option::None);
-    assert_eq!(omitted.to_params().expect("fully omitted optional request must validate"), serde_json::json!([{}]));
+    assert_eq!(
+        super::helius_transaction_subscribe_params(&omitted).expect("fully omitted optional request must validate"),
+        std::vec![serde_json::json!({})]
+    );
     let explicit = crate::HeliusTransactionSubscribeRequest::new(
         crate::HeliusTransactionSubscribeFilter::new(
             std::option::Option::None,
@@ -145,8 +148,8 @@ fn helius_transaction_request_preserves_omitted_explicit_empty_and_explicit_none
         std::option::Option::Some(crate::HeliusTransactionSubscribeOptions::default()),
     );
     assert_eq!(
-        explicit.to_params().expect("explicit empty Helius request states must validate"),
-        serde_json::json!([{"accountInclude":[],"accountExclude":[],"accountRequired":[],"tokenAccounts":"none"}, {}])
+        super::helius_transaction_subscribe_params(&explicit).expect("explicit empty Helius request states must validate"),
+        std::vec![serde_json::json!({"accountInclude":[],"accountExclude":[],"accountRequired":[],"tokenAccounts":"none"}), serde_json::json!({})]
     );
 }
 
@@ -235,21 +238,21 @@ fn helius_transaction_details_require_max_supported_version_only_for_accounts_an
 
 #[test]
 fn helius_transaction_subscribe_and_unsubscribe_control_wire_is_exact() {
-    assert_eq!(crate::helius_transaction_subscribe_method(), "transactionSubscribe");
-    assert_eq!(crate::helius_transaction_unsubscribe_method(), "transactionUnsubscribe");
+    assert_eq!(super::helius_transaction_subscribe_method(), "transactionSubscribe");
+    assert_eq!(super::helius_transaction_unsubscribe_method(), "transactionUnsubscribe");
     assert_eq!(
-        crate::decode_helius_transaction_subscribe_result(serde_json::json!(4_743_323_479_349_712_u64)).expect("numeric ack must decode"),
+        super::decode_helius_transaction_subscribe_result(serde_json::json!(4_743_323_479_349_712_u64)).expect("numeric ack must decode"),
         4_743_323_479_349_712
     );
-    assert_eq!(crate::helius_transaction_unsubscribe_params(4_743_323_479_349_712), serde_json::json!([4_743_323_479_349_712_u64]));
-    assert!(crate::decode_helius_transaction_unsubscribe_result(serde_json::json!(true)).expect("boolean true must decode"));
-    assert!(!crate::decode_helius_transaction_unsubscribe_result(serde_json::json!(false)).expect("boolean false must decode"));
+    assert_eq!(super::helius_transaction_unsubscribe_params(4_743_323_479_349_712), std::vec![serde_json::json!(4_743_323_479_349_712_u64)]);
+    assert!(super::decode_helius_transaction_unsubscribe_result(serde_json::json!(true)).expect("boolean true must decode"));
+    assert!(!super::decode_helius_transaction_unsubscribe_result(serde_json::json!(false)).expect("boolean false must decode"));
     assert_eq!(
-        crate::decode_helius_transaction_subscribe_result(serde_json::json!("not-an-id")).expect_err("non-numeric subscribe ack must fail").code(),
+        super::decode_helius_transaction_subscribe_result(serde_json::json!("not-an-id")).expect_err("non-numeric subscribe ack must fail").code(),
         crate::ERROR_CODE_INVALID_RESPONSE
     );
     assert_eq!(
-        crate::decode_helius_transaction_unsubscribe_result(serde_json::json!(1)).expect_err("non-boolean unsubscribe ack must fail").code(),
+        super::decode_helius_transaction_unsubscribe_result(serde_json::json!(1)).expect_err("non-boolean unsubscribe ack must fail").code(),
         crate::ERROR_CODE_INVALID_RESPONSE
     );
 }
@@ -307,20 +310,20 @@ async fn helius_transaction_control_wire_round_trips_through_shared_physical_act
         std::option::Option::Some(0),
     );
     let request = crate::HeliusTransactionSubscribeRequest::new(filter, std::option::Option::Some(options));
-    let params = request.to_params().expect("typed Helius request must validate before I/O");
+    let params = super::helius_transaction_subscribe_params(&request).expect("typed Helius request must validate before I/O");
     let subscribe_result = session
         .physical_session()
-        .execute_json_rpc(crate::helius_transaction_subscribe_method(), params)
+        .execute_json_rpc(super::helius_transaction_subscribe_method(), params)
         .await
         .expect("transactionSubscribe acknowledgement must arrive");
-    let remote_id = crate::decode_helius_transaction_subscribe_result(subscribe_result).expect("transactionSubscribe id must decode");
+    let remote_id = super::decode_helius_transaction_subscribe_result(subscribe_result).expect("transactionSubscribe id must decode");
     assert_eq!(remote_id, 4242);
     let unsubscribe_result = session
         .physical_session()
-        .execute_json_rpc(crate::helius_transaction_unsubscribe_method(), crate::helius_transaction_unsubscribe_params(remote_id))
+        .execute_json_rpc(super::helius_transaction_unsubscribe_method(), super::helius_transaction_unsubscribe_params(remote_id))
         .await
         .expect("transactionUnsubscribe acknowledgement must arrive");
-    assert!(crate::decode_helius_transaction_unsubscribe_result(unsubscribe_result).expect("transactionUnsubscribe boolean must decode"));
+    assert!(super::decode_helius_transaction_unsubscribe_result(unsubscribe_result).expect("transactionUnsubscribe boolean must decode"));
     session.close().await.expect("Helius fixture session must close");
     server.await.expect("local Helius transaction server must finish");
 }