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

v0.2.8-pre.005-fix.001

Browse Source
This commit is contained in:
SinuS von SifriduS
2026-08-23 15:02:41 +02:00
parent 92224e5ac6
commit 53dbb5bccd
9 changed files with 264 additions and 94 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
crates/ksp-onchain-transport-lib/src/lib.rs
View File

@@ -1,5 +1,5 @@
// file: crates/ksp-onchain-transport-lib/src/lib.rs
// version: 31
// version: 32
#![warn(missing_docs)]
#![deny(unreachable_pub)]
@@ -415,16 +415,6 @@ pub(crate) use self::rpc_common::decode_wire_json;
pub(crate) use self::rpc_common::parse_wire_pubkey;
/// Validates endpoint settings.
pub(crate) use self::settings::validate_endpoint_settings;
/// Crate-internal decoder for Helius transaction-subscribe acknowledgement IDs.
pub(crate) use self::ws_helius_transactions::decode_helius_transaction_subscribe_result;
/// Crate-internal decoder for Helius transaction-unsubscribe boolean results.
pub(crate) use self::ws_helius_transactions::decode_helius_transaction_unsubscribe_result;
/// Crate-internal exact Helius transaction-subscribe method descriptor.
pub(crate) use self::ws_helius_transactions::helius_transaction_subscribe_method;
/// Crate-internal exact Helius transaction-unsubscribe method descriptor.
pub(crate) use self::ws_helius_transactions::helius_transaction_unsubscribe_method;
/// Crate-internal Helius transaction-unsubscribe parameter encoder.
pub(crate) use self::ws_helius_transactions::helius_transaction_unsubscribe_params;
/// Crate-internal command surface shared by the physical session and typed subscription handle.
pub(crate) use self::ws_session::WsSessionCommand;
/// Crate-internal notification dispatch result.

48
crates/ksp-onchain-transport-lib/src/ws_helius_transactions.rs
View File

@@ -1,5 +1,5 @@
// file: crates/ksp-onchain-transport-lib/src/ws_helius_transactions.rs
// version: 1
// version: 2
const MAX_HELIUS_TRANSACTION_FILTER_ACCOUNTS: usize = 50_000;
@@ -325,20 +325,6 @@ impl HeliusTransactionSubscribeRequest {
}
return std::result::Result::Ok(());
}
/// Builds the exact JSON-RPC params array after deterministic validation.
#[allow(dead_code)] // Consumed by actor-owned transaction subscription registration in pre.006.
pub(crate) fn to_params(&self) -> ksp_core_lib::Result<std::vec::Vec<serde_json::Value>> {
let validation = self.validate();
if let std::result::Result::Err(error) = validation {
return std::result::Result::Err(error);
}
let mut params = std::vec![self.filter.to_json_value()];
if let std::option::Option::Some(options) = self.options {
params.push(options.to_json_value());
}
return std::result::Result::Ok(params);
}
}
impl std::fmt::Debug for HeliusTransactionSubscribeRequest {
@@ -347,21 +333,27 @@ impl std::fmt::Debug for HeliusTransactionSubscribeRequest {
}
}
/// Returns the exact Helius transaction-subscribe JSON-RPC method name.
#[allow(dead_code)] // Consumed by actor-owned transaction subscription registration in pre.006.
pub(crate) const fn helius_transaction_subscribe_method() -> &'static str {
fn helius_transaction_subscribe_params(request: &crate::HeliusTransactionSubscribeRequest) -> ksp_core_lib::Result<std::vec::Vec<serde_json::Value>> {
let validation = request.validate();
if let std::result::Result::Err(error) = validation {
return std::result::Result::Err(error);
}
let mut params = std::vec![request.filter.to_json_value()];
if let std::option::Option::Some(options) = request.options {
params.push(options.to_json_value());
}
return std::result::Result::Ok(params);
}
const fn helius_transaction_subscribe_method() -> &'static str {
return "transactionSubscribe";
}
/// Returns the exact Helius transaction-unsubscribe JSON-RPC method name.
#[allow(dead_code)] // Consumed by actor-owned transaction subscription cleanup in pre.006.
pub(crate) const fn helius_transaction_unsubscribe_method() -> &'static str {
const fn helius_transaction_unsubscribe_method() -> &'static str {
return "transactionUnsubscribe";
}
/// Decodes a successful Helius transaction-subscribe acknowledgement without exposing the remote ID publicly.
#[allow(dead_code)] // Consumed by actor-owned transaction subscription registration in pre.006.
pub(crate) fn decode_helius_transaction_subscribe_result(value: serde_json::Value) -> ksp_core_lib::Result<u64> {
fn decode_helius_transaction_subscribe_result(value: serde_json::Value) -> ksp_core_lib::Result<u64> {
return match value.as_u64() {
std::option::Option::Some(remote_id) => std::result::Result::Ok(remote_id),
std::option::Option::None => std::result::Result::Err(
@@ -371,15 +363,11 @@ pub(crate) fn decode_helius_transaction_subscribe_result(value: serde_json::Valu
};
}
/// Builds the exact Helius transaction-unsubscribe params array for one actor-owned remote subscription ID.
#[allow(dead_code)] // Consumed by actor-owned transaction subscription cleanup in pre.006.
pub(crate) fn helius_transaction_unsubscribe_params(remote_id: u64) -> std::vec::Vec<serde_json::Value> {
fn helius_transaction_unsubscribe_params(remote_id: u64) -> std::vec::Vec<serde_json::Value> {
return std::vec![serde_json::Value::Number(remote_id.into())];
}
/// Decodes the boolean Helius transaction-unsubscribe result.
#[allow(dead_code)] // Consumed by actor-owned transaction subscription cleanup in pre.006.
pub(crate) fn decode_helius_transaction_unsubscribe_result(value: serde_json::Value) -> ksp_core_lib::Result<bool> {
fn decode_helius_transaction_unsubscribe_result(value: serde_json::Value) -> ksp_core_lib::Result<bool> {
return match value.as_bool() {
std::option::Option::Some(unsubscribed) => std::result::Result::Ok(unsubscribed),
std::option::Option::None => std::result::Result::Err(

51
crates/ksp-onchain-transport-lib/unit_tests/ws_helius_transactions.rs
View File

@@ -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");
}