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

v0.2.4-pre.007

Browse Source
This commit is contained in:
SinuS von SifriduS
2026-08-18 21:33:21 +02:00
parent 7a889dd466
commit 4252a21140
13 changed files with 898 additions and 14 deletions
Download Patch File Download Diff File Expand all files Collapse all files

225
crates/ksp-onchain-transport-lib/unit_tests/rpc_economics.rs
View File

@@ -1,5 +1,5 @@
// file: crates/ksp-onchain-transport-lib/unit_tests/rpc_economics.rs
// version: 1
// version: 2
#[test]
fn inflation_reward_config_preserves_epoch_commitment_and_min_context_slot() {
@@ -84,3 +84,226 @@ fn supply_rejects_invalid_non_circulating_pubkey_without_echoing_value() {
assert_eq!(error.code(), crate::ERROR_CODE_INVALID_RESPONSE);
assert!(!error.to_string().contains("invalid-pubkey"));
}
fn pool_for_url(url: &str) -> crate::HttpTransportPool {
let role = crate::HttpEndpointRoleSettings::new(
crate::HttpRoleName::new("default"),
true,
std::vec![crate::HttpRequestKind::wildcard()],
10,
crate::HttpRoleLimits::new(std::option::Option::None, std::option::Option::None, std::option::Option::None, std::option::Option::None),
);
let endpoint = crate::HttpEndpointSettings::new(
"fixture",
true,
crate::HttpProviderName::new("fixture"),
crate::HttpClusterName::new("local"),
crate::HttpEndpointUrl::parse(url).expect("fixture URL must parse"),
std::time::Duration::from_secs(1),
std::time::Duration::from_secs(1),
std::option::Option::Some(1),
std::vec![role],
);
let settings = crate::HttpTransportSettings::new(
std::vec![endpoint],
crate::HttpRetrySettings::new(0, std::time::Duration::from_millis(1), std::time::Duration::from_millis(1)),
);
return crate::HttpTransportPool::new(settings).expect("fixture pool must build");
}
fn serve_once(body: &'static str) -> (std::string::String, std::thread::JoinHandle<std::string::String>) {
let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("fixture listener must bind");
let address = listener.local_addr().expect("fixture listener address must resolve");
let handle = std::thread::spawn(move || {
let (mut stream, _) = listener.accept().expect("fixture server must accept one request");
let request = read_request(&mut stream);
let response = format!("HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{}", body.len(), body);
std::io::Write::write_all(&mut stream, response.as_bytes()).expect("fixture response must write");
return request;
});
return (format!("http://{address}"), handle);
}
fn read_request(stream: &mut std::net::TcpStream) -> std::string::String {
let mut bytes = std::vec::Vec::new();
let mut buffer = [0_u8; 1024];
loop {
let count = std::io::Read::read(stream, &mut buffer).expect("fixture request must read");
if count == 0 {
break;
}
bytes.extend_from_slice(&buffer[..count]);
if request_complete(bytes.as_slice()) {
break;
}
}
return std::string::String::from_utf8(bytes).expect("fixture request must be UTF-8");
}
fn request_complete(bytes: &[u8]) -> bool {
let text = match std::str::from_utf8(bytes) {
std::result::Result::Ok(text) => text,
std::result::Result::Err(_) => return false,
};
let header_end = match text.find("\r\n\r\n") {
std::option::Option::Some(value) => value,
std::option::Option::None => return false,
};
let mut content_length = 0_usize;
for line in text[..header_end].lines() {
let (name, value) = match line.split_once(':') {
std::option::Option::Some(parts) => parts,
std::option::Option::None => continue,
};
if name.eq_ignore_ascii_case("content-length") {
content_length = value.trim().parse::<usize>().expect("content length must parse");
}
}
return bytes.len() >= header_end.saturating_add(4).saturating_add(content_length);
}
fn request_body(request: &str) -> serde_json::Value {
let body = request.split("\r\n\r\n").nth(1).expect("fixture request body must exist");
return serde_json::from_str(body).expect("fixture request body must be JSON");
}
#[tokio::test(flavor = "current_thread")]
async fn typed_get_inflation_governor_serializes_processed_commitment_and_preserves_runtime_values() {
let (url, handle) = serve_once(include_str!("../fixtures/http/get_inflation_governor.success.json"));
let pool = pool_for_url(url.as_str());
let config = crate::SolanaCommitmentConfig::new(std::option::Option::Some(crate::SolanaCommitment::Processed));
let governor = pool
.get_inflation_governor(&crate::HttpRoleName::new("default"), std::option::Option::Some(&config))
.await
.expect("inflation governor fixture must succeed");
assert_eq!(governor.initial(), 0.07123456789);
assert_eq!(governor.terminal(), 0.0123456789);
assert_eq!(governor.taper(), 0.2718281828);
assert_eq!(governor.foundation(), 0.0042);
assert_eq!(governor.foundation_term(), 6.25);
let request = handle.join().expect("fixture server must join");
let body = request_body(request.as_str());
assert_eq!(body["method"], serde_json::json!("getInflationGovernor"));
assert_eq!(body["params"], serde_json::json!([{"commitment":"processed"}]));
}
#[tokio::test(flavor = "current_thread")]
async fn typed_get_inflation_governor_omits_absent_and_empty_config() {
let role = crate::HttpRoleName::new("default");
let empty = crate::SolanaCommitmentConfig::default();
for config in [std::option::Option::None, std::option::Option::Some(&empty)] {
let (url, handle) = serve_once(include_str!("../fixtures/http/get_inflation_governor.success.json"));
let pool = pool_for_url(url.as_str());
pool.get_inflation_governor(&role, config).await.expect("inflation governor fixture must succeed");
let request = handle.join().expect("fixture server must join");
assert_eq!(request_body(request.as_str())["params"], serde_json::json!([]));
}
}
#[tokio::test(flavor = "current_thread")]
async fn typed_get_inflation_rate_has_no_params_and_preserves_runtime_values() {
let (url, handle) = serve_once(include_str!("../fixtures/http/get_inflation_rate.success.json"));
let pool = pool_for_url(url.as_str());
let rate = pool.get_inflation_rate(&crate::HttpRoleName::new("default")).await.expect("inflation rate fixture must succeed");
assert_eq!(rate.total(), 0.0387654321);
assert_eq!(rate.validator(), 0.037654321);
assert_eq!(rate.foundation(), 0.0011111111);
assert_eq!(rate.epoch(), 913);
let request = handle.join().expect("fixture server must join");
let body = request_body(request.as_str());
assert_eq!(body["method"], serde_json::json!("getInflationRate"));
assert_eq!(body["params"], serde_json::json!([]));
}
#[tokio::test(flavor = "current_thread")]
async fn typed_get_stake_minimum_delegation_preserves_context_and_runtime_value_without_local_minimum() {
let (url, handle) = serve_once(include_str!("../fixtures/http/get_stake_minimum_delegation.success.json"));
let pool = pool_for_url(url.as_str());
let config = crate::SolanaContextConfig::new(std::option::Option::Some(crate::SolanaCommitment::Processed), std::option::Option::Some(431_000_000));
let result = pool
.get_stake_minimum_delegation(&crate::HttpRoleName::new("default"), std::option::Option::Some(&config))
.await
.expect("stake minimum delegation fixture must succeed");
assert_eq!(*result.value(), 42_424_242);
assert_eq!(result.context().slot(), 431_000_123);
assert_eq!(result.context().api_version(), std::option::Option::Some("4.2.1"));
let request = handle.join().expect("fixture server must join");
assert_eq!(request_body(request.as_str())["params"], serde_json::json!([{"commitment":"processed","minContextSlot":431000000}]));
}
#[tokio::test(flavor = "current_thread")]
async fn typed_get_stake_minimum_delegation_omits_absent_and_empty_config() {
let role = crate::HttpRoleName::new("default");
let empty = crate::SolanaContextConfig::default();
for config in [std::option::Option::None, std::option::Option::Some(&empty)] {
let (url, handle) = serve_once(include_str!("../fixtures/http/get_stake_minimum_delegation.success.json"));
let pool = pool_for_url(url.as_str());
pool.get_stake_minimum_delegation(&role, config).await.expect("stake minimum delegation fixture must succeed");
let request = handle.join().expect("fixture server must join");
assert_eq!(request_body(request.as_str())["params"], serde_json::json!([]));
}
}
#[tokio::test(flavor = "current_thread")]
async fn typed_get_supply_preserves_explicit_false_full_account_list_and_context() {
let (url, handle) = serve_once(include_str!("../fixtures/http/get_supply.success.json"));
let pool = pool_for_url(url.as_str());
let config = crate::SolanaSupplyConfig::new(std::option::Option::Some(crate::SolanaCommitment::Processed), std::option::Option::Some(false));
let result = pool.get_supply(&crate::HttpRoleName::new("default"), std::option::Option::Some(&config)).await.expect("supply fixture must succeed");
assert_eq!(result.context().slot(), 431_000_124);
assert_eq!(result.value().total(), 610_000_000_000_000_000);
assert_eq!(result.value().circulating(), 510_000_000_000_000_000);
assert_eq!(result.value().non_circulating(), 100_000_000_000_000_000);
assert_eq!(result.value().non_circulating_accounts().len(), 2);
let request = handle.join().expect("fixture server must join");
assert_eq!(request_body(request.as_str())["params"], serde_json::json!([{"commitment":"processed","excludeNonCirculatingAccountsList":false}]));
}
#[tokio::test(flavor = "current_thread")]
async fn typed_get_supply_preserves_explicit_true_as_empty_runtime_account_list() {
let (url, handle) = serve_once(include_str!("../fixtures/http/get_supply.excluded.success.json"));
let pool = pool_for_url(url.as_str());
let config = crate::SolanaSupplyConfig::new(std::option::Option::None, std::option::Option::Some(true));
let result = pool
.get_supply(&crate::HttpRoleName::new("default"), std::option::Option::Some(&config))
.await
.expect("excluded supply fixture must succeed");
assert_eq!(result.value().non_circulating_accounts(), &[]);
assert_eq!(result.value().non_circulating(), 100_000_000_000_000_000);
let request = handle.join().expect("fixture server must join");
assert_eq!(request_body(request.as_str())["params"], serde_json::json!([{"excludeNonCirculatingAccountsList":true}]));
}
#[tokio::test(flavor = "current_thread")]
async fn typed_get_supply_omits_absent_and_empty_config() {
let role = crate::HttpRoleName::new("default");
let empty = crate::SolanaSupplyConfig::default();
for config in [std::option::Option::None, std::option::Option::Some(&empty)] {
let (url, handle) = serve_once(include_str!("../fixtures/http/get_supply.success.json"));
let pool = pool_for_url(url.as_str());
pool.get_supply(&role, config).await.expect("supply fixture must succeed");
let request = handle.join().expect("fixture server must join");
assert_eq!(request_body(request.as_str())["params"], serde_json::json!([]));
}
}
#[tokio::test(flavor = "current_thread")]
async fn typed_get_stake_minimum_delegation_preserves_min_context_slot_rpc_error() {
let (url, handle) = serve_once(include_str!("../fixtures/http/get_stake_minimum_delegation.error_min_context.json"));
let pool = pool_for_url(url.as_str());
let config = crate::SolanaContextConfig::new(std::option::Option::None, std::option::Option::Some(431_000_000));
let result = pool.get_stake_minimum_delegation(&crate::HttpRoleName::new("default"), std::option::Option::Some(&config)).await;
let error = result.expect_err("min-context-slot RPC error must propagate");
assert_eq!(error.code(), crate::ERROR_CODE_RPC_APPLICATION_ERROR);
handle.join().expect("fixture server must join");
}
#[tokio::test(flavor = "current_thread")]
async fn typed_get_supply_preserves_scan_rpc_error() {
let (url, handle) = serve_once(include_str!("../fixtures/http/get_supply.error_scan.json"));
let pool = pool_for_url(url.as_str());
let result = pool.get_supply(&crate::HttpRoleName::new("default"), std::option::Option::None).await;
let error = result.expect_err("supply scan RPC error must propagate");
assert_eq!(error.code(), crate::ERROR_CODE_RPC_APPLICATION_ERROR);
handle.join().expect("fixture server must join");
}