Sasedev/khadhroony-solana-project
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

v0.2.7-pre.010

Browse Source
This commit is contained in:
SinuS von SifriduS
2026-08-23 00:12:39 +02:00
parent 98bf88e431
commit 1391858972
14 changed files with 838 additions and 29 deletions
Download Patch File Download Diff File Expand all files Collapse all files

100
crates/ksp-onchain-transport-lib/unit_tests/ws_cluster.rs Normal file
View File

@@ -0,0 +1,100 @@
// file: crates/ksp-onchain-transport-lib/unit_tests/ws_cluster.rs
// version: 1
use futures_util::SinkExt; // rust-rules: trait-import
use futures_util::StreamExt; // rust-rules: trait-import
fn local_endpoint(url: &str) -> crate::WsEndpointSettings {
return crate::WsEndpointSettings::new(
"local_ws_cluster",
true,
crate::WsProviderName::new("local-fixture"),
crate::WsClusterName::new("local"),
crate::WsProtocolKind::SolanaStandard,
crate::WsEndpointUrl::parse(url).expect("local test WebSocket URL must parse"),
crate::WsSessionSettings::default(),
);
}
async fn bind_local_listener() -> (tokio::net::TcpListener, std::string::String) {
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.expect("local listener must bind");
let address = listener.local_addr().expect("local listener must expose address");
return (listener, format!("ws://{address}"));
}
async fn read_request(websocket: &mut tokio_tungstenite::WebSocketStream<tokio::net::TcpStream>) -> serde_json::Value {
let message = websocket.next().await.expect("request message must exist").expect("request message must decode");
let text = message.to_text().expect("request must be text");
return serde_json::from_str(text).expect("request must contain JSON");
}
async fn send_result(websocket: &mut tokio_tungstenite::WebSocketStream<tokio::net::TcpStream>, request: &serde_json::Value, result: serde_json::Value) {
let id = request.get("id").and_then(serde_json::Value::as_u64).expect("request id must be numeric");
let response = serde_json::json!({"jsonrpc":"2.0","id":id,"result":result});
websocket.send(tokio_tungstenite::tungstenite::Message::Text(response.to_string().into())).await.expect("local response must send");
}
async fn send_notification(websocket: &mut tokio_tungstenite::WebSocketStream<tokio::net::TcpStream>, method: &str, remote_id: u64, result: serde_json::Value) {
let notification = serde_json::json!({"jsonrpc":"2.0","method":method,"params":{"result":result,"subscription":remote_id}});
websocket.send(tokio_tungstenite::tungstenite::Message::Text(notification.to_string().into())).await.expect("local notification must send");
}
async fn wait_for_close_frame(websocket: &mut tokio_tungstenite::WebSocketStream<tokio::net::TcpStream>) {
loop {
let message = websocket.next().await;
match message {
std::option::Option::Some(std::result::Result::Ok(tokio_tungstenite::tungstenite::Message::Close(_))) => return,
std::option::Option::Some(std::result::Result::Ok(_)) => {},
std::option::Option::Some(std::result::Result::Err(_)) | std::option::Option::None => return,
}
}
}
#[test]
fn slot_notification_decoder_preserves_slot_parent_and_root() {
let notification =
super::decode_slot_notification("slotSubscribe", serde_json::json!({"slot":76,"parent":75,"root":44})).expect("slot notification must decode");
assert_eq!(notification.slot(), 76);
assert_eq!(notification.parent(), 75);
assert_eq!(notification.root(), 44);
assert!(super::decode_slot_notification("slotSubscribe", serde_json::json!({"slot":76,"parent":75})).is_err());
}
#[tokio::test(flavor = "current_thread")]
async fn stable_slot_and_root_wrappers_use_no_params_decode_exact_notifications_and_unsubscribe_by_handle() {
let (listener, url) = bind_local_listener().await;
let server = tokio::spawn(async move {
let (stream, _) = listener.accept().await.expect("local server must accept client");
let mut websocket = tokio_tungstenite::accept_async(stream).await.expect("local WebSocket handshake must succeed");
let slot_subscribe = read_request(&mut websocket).await;
assert_eq!(slot_subscribe["method"], serde_json::json!("slotSubscribe"));
assert_eq!(slot_subscribe["params"], serde_json::json!([]));
send_result(&mut websocket, &slot_subscribe, serde_json::json!(201)).await;
send_notification(&mut websocket, "slotNotification", 201, serde_json::json!({"slot":76,"parent":75,"root":44})).await;
let root_subscribe = read_request(&mut websocket).await;
assert_eq!(root_subscribe["method"], serde_json::json!("rootSubscribe"));
assert_eq!(root_subscribe["params"], serde_json::json!([]));
send_result(&mut websocket, &root_subscribe, serde_json::json!(202)).await;
send_notification(&mut websocket, "rootNotification", 202, serde_json::json!(42)).await;
let slot_unsubscribe = read_request(&mut websocket).await;
assert_eq!(slot_unsubscribe["method"], serde_json::json!("slotUnsubscribe"));
assert_eq!(slot_unsubscribe["params"], serde_json::json!([201]));
send_result(&mut websocket, &slot_unsubscribe, serde_json::json!(true)).await;
let root_unsubscribe = read_request(&mut websocket).await;
assert_eq!(root_unsubscribe["method"], serde_json::json!("rootUnsubscribe"));
assert_eq!(root_unsubscribe["params"], serde_json::json!([202]));
send_result(&mut websocket, &root_unsubscribe, serde_json::json!(true)).await;
wait_for_close_frame(&mut websocket).await;
});
let session = crate::WsSession::connect(local_endpoint(url.as_str())).await.expect("client handshake must succeed");
let mut slot_subscription = session.slot_subscribe().await.expect("slotSubscribe must register");
let slot = slot_subscription.recv().await.expect("slot notification must arrive").expect("slot notification must decode");
assert_eq!((slot.slot(), slot.parent(), slot.root()), (76, 75, 44));
let mut root_subscription = session.root_subscribe().await.expect("rootSubscribe must register");
let root = root_subscription.recv().await.expect("root notification must arrive").expect("root notification must decode");
assert_eq!(root, 42);
assert!(slot_subscription.unsubscribe().await.expect("slot unsubscribe must complete"));
assert!(root_subscription.unsubscribe().await.expect("root unsubscribe must complete"));
session.close().await.expect("session close must complete");
server.await.expect("local server task must complete");
}

126
crates/ksp-onchain-transport-lib/unit_tests/ws_transactions.rs
View File

@@ -1,5 +1,5 @@
// file: crates/ksp-onchain-transport-lib/unit_tests/ws_transactions.rs
// version: 1
// version: 2
use futures_util::SinkExt; // rust-rules: trait-import
use futures_util::StreamExt; // rust-rules: trait-import
@@ -120,3 +120,127 @@ async fn stable_logs_wrapper_uses_exact_filter_config_notification_and_handle_un
session.close().await.expect("session close must complete");
server.await.expect("local server task must complete");
}
#[test]
fn signature_subscribe_config_and_decoder_preserve_all_documented_wire_variants() {
let config = crate::SolanaSignatureSubscribeConfig::new(std::option::Option::Some(crate::SolanaCommitment::Confirmed), std::option::Option::Some(false));
assert_eq!(config.commitment(), std::option::Option::Some(crate::SolanaCommitment::Confirmed));
assert_eq!(config.enable_received_notification(), std::option::Option::Some(false));
assert_eq!(config.to_json_value(), serde_json::json!({"commitment":"confirmed","enableReceivedNotification":false}));
let received = super::decode_signature_notification("signatureSubscribe", serde_json::json!({"context":{"slot":90},"value":"receivedSignature"}))
.expect("receivedSignature notification must decode");
assert_eq!(received.context().slot(), 90);
assert_eq!(*received.value(), crate::SolanaSignatureNotification::ReceivedSignature);
assert!(!received.value().is_terminal());
let success = super::decode_signature_notification("signatureSubscribe", serde_json::json!({"context":{"slot":91},"value":{"err":null}}))
.expect("terminal successful signature notification must decode");
assert!(success.value().is_terminal());
assert!(success.value().err().is_none());
let failure = super::decode_signature_notification(
"signatureSubscribe",
serde_json::json!({"context":{"slot":92},"value":{"err":{"InstructionError":[0,"Custom"]}}}),
)
.expect("terminal failed signature notification must decode");
assert!(failure.value().is_terminal());
assert!(failure.value().err().is_some());
assert!(super::decode_signature_notification("signatureSubscribe", serde_json::json!({"context":{"slot":93},"value":"futureVariant"})).is_err());
assert!(super::decode_signature_notification("signatureSubscribe", serde_json::json!({"context":{"slot":94},"value":{}})).is_err());
}
#[tokio::test(flavor = "current_thread")]
async fn signature_unsubscribe_before_terminal_notification_uses_current_remote_id() {
let (listener, url) = bind_local_listener().await;
let server = tokio::spawn(async move {
let (stream, _) = listener.accept().await.expect("local server must accept client");
let mut websocket = tokio_tungstenite::accept_async(stream).await.expect("local WebSocket handshake must succeed");
let subscribe = read_request(&mut websocket).await;
assert_eq!(subscribe["method"], serde_json::json!("signatureSubscribe"));
assert_eq!(subscribe["params"], serde_json::json!(["fixture-signature"]));
send_result(&mut websocket, &subscribe, serde_json::json!(301)).await;
let unsubscribe = read_request(&mut websocket).await;
assert_eq!(unsubscribe["method"], serde_json::json!("signatureUnsubscribe"));
assert_eq!(unsubscribe["params"], serde_json::json!([301]));
send_result(&mut websocket, &unsubscribe, serde_json::json!(true)).await;
wait_for_close_frame(&mut websocket).await;
});
let session = crate::WsSession::connect(local_endpoint(url.as_str())).await.expect("client handshake must succeed");
let empty_config = crate::SolanaSignatureSubscribeConfig::default();
let mut subscription =
session.signature_subscribe("fixture-signature", std::option::Option::Some(&empty_config)).await.expect("signatureSubscribe must register");
assert!(subscription.unsubscribe().await.expect("signature unsubscribe must complete"));
assert_eq!(subscription.state(), crate::WsSubscriptionState::Closed);
session.close().await.expect("session close must complete");
server.await.expect("local server task must complete");
}
#[tokio::test(flavor = "current_thread")]
async fn signature_terminal_notification_closes_handle_and_is_not_resubscribed_after_reconnect() {
let (listener, url) = bind_local_listener().await;
let (send_terminal_tx, send_terminal_rx) = tokio::sync::oneshot::channel();
let (replacement_ready_tx, replacement_ready_rx) = tokio::sync::oneshot::channel();
let server = tokio::spawn(async move {
let (stream, _) = listener.accept().await.expect("local server must accept initial client");
let mut websocket = tokio_tungstenite::accept_async(stream).await.expect("initial WebSocket handshake must succeed");
let subscribe = read_request(&mut websocket).await;
assert_eq!(subscribe["method"], serde_json::json!("signatureSubscribe"));
assert_eq!(subscribe["params"], serde_json::json!(["fixture-signature",{"commitment":"finalized","enableReceivedNotification":true}]));
send_result(&mut websocket, &subscribe, serde_json::json!(401)).await;
let received = serde_json::json!({
"jsonrpc":"2.0",
"method":"signatureNotification",
"params":{"result":{"context":{"slot":100},"value":"receivedSignature"},"subscription":401}
});
websocket
.send(tokio_tungstenite::tungstenite::Message::Text(received.to_string().into()))
.await
.expect("receivedSignature notification must send");
send_terminal_rx.await.expect("client must observe early signature notification before terminal send");
let terminal = serde_json::json!({
"jsonrpc":"2.0",
"method":"signatureNotification",
"params":{"result":{"context":{"slot":101},"value":{"err":null}},"subscription":401}
});
websocket
.send(tokio_tungstenite::tungstenite::Message::Text(terminal.to_string().into()))
.await
.expect("terminal signature notification must send");
let unexpected_cleanup = tokio::time::timeout(std::time::Duration::from_millis(100), websocket.next()).await;
assert!(unexpected_cleanup.is_err(), "server-terminal signature notification must not trigger signatureUnsubscribe");
drop(websocket);
let (replacement_stream, _) = listener.accept().await.expect("local server must accept replacement client");
let mut replacement = tokio_tungstenite::accept_async(replacement_stream).await.expect("replacement WebSocket handshake must succeed");
let unexpected = tokio::time::timeout(std::time::Duration::from_millis(100), replacement.next()).await;
assert!(unexpected.is_err(), "terminal signature subscription must not be replayed after reconnect");
replacement_ready_tx.send(()).expect("replacement-ready signal must send");
wait_for_close_frame(&mut replacement).await;
});
let session = crate::WsSession::connect(local_endpoint(url.as_str())).await.expect("client handshake must succeed");
let config = crate::SolanaSignatureSubscribeConfig::new(std::option::Option::Some(crate::SolanaCommitment::Finalized), std::option::Option::Some(true));
let mut subscription =
session.signature_subscribe("fixture-signature", std::option::Option::Some(&config)).await.expect("signatureSubscribe must register");
let received = subscription.recv().await.expect("receivedSignature must arrive").expect("receivedSignature must decode");
assert_eq!(*received.value(), crate::SolanaSignatureNotification::ReceivedSignature);
assert_eq!(subscription.state(), crate::WsSubscriptionState::Active);
send_terminal_tx.send(()).expect("terminal-send signal must reach fixture");
let terminal = subscription.recv().await.expect("terminal signature notification must arrive").expect("terminal signature notification must decode");
assert!(terminal.value().is_terminal());
assert!(terminal.value().err().is_none());
let closed = tokio::time::timeout(std::time::Duration::from_secs(1), async {
loop {
if subscription.state() == crate::WsSubscriptionState::Closed {
return;
}
tokio::task::yield_now().await;
}
})
.await;
assert!(closed.is_ok());
assert!(subscription.recv().await.is_none());
assert!(subscription.terminal_error_code().is_none());
assert!(!subscription.unsubscribe().await.expect("already terminal signature unsubscribe must be local-only"));
replacement_ready_rx.await.expect("replacement connection must be observed without signature replay");
assert_eq!(session.snapshot().subscription_count(), 0);
assert!(session.snapshot().continuity_gap_count() >= 1);
session.close().await.expect("session close must complete");
server.await.expect("local server task must complete");
}