492 lines
27 KiB
Rust
492 lines
27 KiB
Rust
// file: crates/ksp-onchain-transport-lib/unit_tests/rpc_economics.rs
|
|
// version: 4
|
|
|
|
#[test]
|
|
fn inflation_reward_config_preserves_epoch_commitment_and_min_context_slot() {
|
|
let config = crate::SolanaInflationRewardConfig::new(
|
|
std::option::Option::Some(811),
|
|
std::option::Option::Some(crate::SolanaCommitment::Finalized),
|
|
std::option::Option::Some(429_000_000),
|
|
);
|
|
assert_eq!(config.epoch(), std::option::Option::Some(811));
|
|
assert_eq!(config.commitment(), std::option::Option::Some(crate::SolanaCommitment::Finalized));
|
|
assert_eq!(config.min_context_slot(), std::option::Option::Some(429_000_000));
|
|
assert_eq!(config.to_json_value(), serde_json::json!({"epoch":811,"commitment":"finalized","minContextSlot":429000000}));
|
|
assert!(crate::SolanaInflationRewardConfig::default().is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn supply_config_distinguishes_omitted_from_explicit_false() {
|
|
let omitted = crate::SolanaSupplyConfig::default();
|
|
let explicit_false = crate::SolanaSupplyConfig::new(std::option::Option::Some(crate::SolanaCommitment::Confirmed), std::option::Option::Some(false));
|
|
assert!(omitted.is_empty());
|
|
assert_eq!(omitted.to_json_value(), serde_json::json!({}));
|
|
assert_eq!(explicit_false.exclude_non_circulating_accounts_list(), std::option::Option::Some(false));
|
|
assert_eq!(explicit_false.to_json_value(), serde_json::json!({"commitment":"confirmed","excludeNonCirculatingAccountsList":false}));
|
|
}
|
|
|
|
#[test]
|
|
fn inflation_governor_and_rate_fixtures_preserve_runtime_values() {
|
|
let governor_value = serde_json::from_str::<serde_json::Value>(include_str!("../fixtures/http/inflation_governor.v4_2_1.json"))
|
|
.expect("inflation governor fixture must decode");
|
|
let rate_value =
|
|
serde_json::from_str::<serde_json::Value>(include_str!("../fixtures/http/inflation_rate.v4_2_1.json")).expect("inflation rate fixture must decode");
|
|
let governor = crate::SolanaInflationGovernor::decode_wire("getInflationGovernor", governor_value).expect("inflation governor must decode");
|
|
let rate = crate::SolanaInflationRate::decode_wire("getInflationRate", rate_value).expect("inflation rate must decode");
|
|
assert_eq!(governor.initial(), 0.08);
|
|
assert_eq!(governor.terminal(), 0.015);
|
|
assert_eq!(governor.taper(), 0.15);
|
|
assert_eq!(governor.foundation(), 0.05);
|
|
assert_eq!(governor.foundation_term(), 7.0);
|
|
assert_eq!(rate.total(), 0.042);
|
|
assert_eq!(rate.validator(), 0.041);
|
|
assert_eq!(rate.foundation(), 0.001);
|
|
assert_eq!(rate.epoch(), 812);
|
|
}
|
|
|
|
#[test]
|
|
fn inflation_reward_fixture_preserves_position_null_and_commission_bps_states() {
|
|
let values = serde_json::from_str::<std::vec::Vec<serde_json::Value>>(include_str!("../fixtures/http/inflation_reward.variants.json"))
|
|
.expect("inflation reward fixtures must decode");
|
|
let first = crate::SolanaInflationReward::decode_wire("getInflationReward", values[0].clone()).expect("first reward must decode");
|
|
let third = crate::SolanaInflationReward::decode_wire("getInflationReward", values[2].clone()).expect("third reward must decode");
|
|
assert_eq!(values.len(), 3);
|
|
assert!(values[1].is_null());
|
|
assert_eq!(first.epoch(), 811);
|
|
assert_eq!(first.effective_slot(), 429_900_000);
|
|
assert_eq!(first.amount(), 2_500_000);
|
|
assert_eq!(first.post_balance(), 1_002_500_000);
|
|
assert_eq!(first.commission(), std::option::Option::Some(7));
|
|
assert_eq!(first.commission_bps().value(), std::option::Option::Some(&725));
|
|
assert_eq!(third.commission(), std::option::Option::None);
|
|
assert!(third.commission_bps().is_omitted());
|
|
}
|
|
|
|
#[test]
|
|
fn supply_fixture_types_non_circulating_accounts_and_preserves_order() {
|
|
let value = serde_json::from_str::<serde_json::Value>(include_str!("../fixtures/http/supply.v4_2_1.json")).expect("supply fixture must decode");
|
|
let supply = crate::SolanaSupply::decode_wire("getSupply", value).expect("supply must decode");
|
|
assert_eq!(supply.total(), 600_000_000_000_000_000);
|
|
assert_eq!(supply.circulating(), 500_000_000_000_000_000);
|
|
assert_eq!(supply.non_circulating(), 100_000_000_000_000_000);
|
|
assert_eq!(supply.non_circulating_accounts().len(), 2);
|
|
assert_eq!(supply.non_circulating_accounts()[0].to_string(), "11111111111111111111111111111111");
|
|
assert_eq!(supply.non_circulating_accounts()[1].to_string(), "Vote111111111111111111111111111111111111111");
|
|
}
|
|
|
|
#[test]
|
|
fn supply_rejects_invalid_non_circulating_pubkey_without_echoing_value() {
|
|
let result = crate::SolanaSupply::decode_wire(
|
|
"getSupply",
|
|
serde_json::json!({"total":3,"circulating":2,"nonCirculating":1,"nonCirculatingAccounts":["invalid-pubkey"]}),
|
|
);
|
|
let error = result.expect_err("invalid supply pubkey must fail closed");
|
|
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");
|
|
}
|
|
|
|
fn inflation_reward_fixture_pubkey(value: &str) -> ksp_core_lib::Pubkey {
|
|
return value.parse::<ksp_core_lib::Pubkey>().expect("fixture inflation-reward pubkey must parse");
|
|
}
|
|
|
|
#[tokio::test(flavor = "current_thread")]
|
|
async fn typed_get_inflation_reward_serializes_full_config_and_preserves_position_and_commission_states() {
|
|
let (url, handle) = serve_once(include_str!("../fixtures/http/get_inflation_reward.success.json"));
|
|
let pool = pool_for_url(url.as_str());
|
|
let addresses = std::vec![
|
|
inflation_reward_fixture_pubkey("11111111111111111111111111111111"),
|
|
inflation_reward_fixture_pubkey("Vote111111111111111111111111111111111111111"),
|
|
inflation_reward_fixture_pubkey("SysvarRent111111111111111111111111111111111"),
|
|
inflation_reward_fixture_pubkey("Stake11111111111111111111111111111111111111"),
|
|
];
|
|
let config = crate::SolanaInflationRewardConfig::new(
|
|
std::option::Option::Some(912),
|
|
std::option::Option::Some(crate::SolanaCommitment::Finalized),
|
|
std::option::Option::Some(431_000_000),
|
|
);
|
|
let rewards = pool
|
|
.get_inflation_reward(&crate::HttpRoleName::new("default"), addresses.as_slice(), std::option::Option::Some(&config))
|
|
.await
|
|
.expect("inflation reward fixture must succeed");
|
|
assert_eq!(rewards.len(), addresses.len());
|
|
let first = rewards[0].as_ref().expect("first reward must be present");
|
|
assert_eq!(first.epoch(), 912);
|
|
assert_eq!(first.effective_slot(), 431_500_001);
|
|
assert_eq!(first.amount(), 2_500_000);
|
|
assert_eq!(first.post_balance(), 1_002_500_000);
|
|
assert_eq!(first.commission(), std::option::Option::Some(7));
|
|
assert_eq!(first.commission_bps().value(), std::option::Option::Some(&725));
|
|
assert!(rewards[1].is_none());
|
|
let third = rewards[2].as_ref().expect("third reward must be present");
|
|
assert_eq!(third.commission(), std::option::Option::None);
|
|
assert!(third.commission_bps().is_omitted());
|
|
let fourth = rewards[3].as_ref().expect("fourth reward must be present");
|
|
assert_eq!(fourth.commission(), std::option::Option::Some(3));
|
|
assert!(fourth.commission_bps().is_null());
|
|
let request = handle.join().expect("fixture server must join");
|
|
let body = request_body(request.as_str());
|
|
assert_eq!(body["method"], serde_json::json!("getInflationReward"));
|
|
assert_eq!(
|
|
body["params"],
|
|
serde_json::json!([
|
|
[
|
|
"11111111111111111111111111111111",
|
|
"Vote111111111111111111111111111111111111111",
|
|
"SysvarRent111111111111111111111111111111111",
|
|
"Stake11111111111111111111111111111111111111"
|
|
],
|
|
{"epoch":912,"commitment":"finalized","minContextSlot":431000000}
|
|
])
|
|
);
|
|
}
|
|
|
|
#[tokio::test(flavor = "current_thread")]
|
|
async fn typed_get_inflation_reward_preserves_duplicate_input_order_and_positional_nulls() {
|
|
let (url, handle) = serve_once(include_str!("../fixtures/http/get_inflation_reward.duplicates.json"));
|
|
let pool = pool_for_url(url.as_str());
|
|
let first = inflation_reward_fixture_pubkey("11111111111111111111111111111111");
|
|
let second = inflation_reward_fixture_pubkey("Vote111111111111111111111111111111111111111");
|
|
let addresses = std::vec![first, second, first];
|
|
let rewards = pool
|
|
.get_inflation_reward(&crate::HttpRoleName::new("default"), addresses.as_slice(), std::option::Option::None)
|
|
.await
|
|
.expect("duplicate inflation reward fixture must succeed");
|
|
assert_eq!(rewards.len(), 3);
|
|
assert_eq!(rewards[0], rewards[2]);
|
|
assert!(rewards[1].is_none());
|
|
let request = handle.join().expect("fixture server must join");
|
|
assert_eq!(
|
|
request_body(request.as_str())["params"],
|
|
serde_json::json!([["11111111111111111111111111111111", "Vote111111111111111111111111111111111111111", "11111111111111111111111111111111"]])
|
|
);
|
|
}
|
|
|
|
#[tokio::test(flavor = "current_thread")]
|
|
async fn typed_get_inflation_reward_omits_absent_and_empty_config_but_keeps_address_parameter() {
|
|
let role = crate::HttpRoleName::new("default");
|
|
let address = inflation_reward_fixture_pubkey("11111111111111111111111111111111");
|
|
let addresses = std::vec![address];
|
|
let empty = crate::SolanaInflationRewardConfig::default();
|
|
for config in [std::option::Option::None, std::option::Option::Some(&empty)] {
|
|
let (url, handle) = serve_once(include_str!("../fixtures/http/get_inflation_reward.single_null.json"));
|
|
let pool = pool_for_url(url.as_str());
|
|
let rewards = pool.get_inflation_reward(&role, addresses.as_slice(), config).await.expect("single null inflation reward fixture must succeed");
|
|
assert_eq!(rewards, std::vec![std::option::Option::None]);
|
|
let request = handle.join().expect("fixture server must join");
|
|
assert_eq!(request_body(request.as_str())["params"], serde_json::json!([["11111111111111111111111111111111"]]));
|
|
}
|
|
}
|
|
|
|
#[tokio::test(flavor = "current_thread")]
|
|
async fn typed_get_inflation_reward_accepts_empty_address_list_without_inventing_a_minimum() {
|
|
let (url, handle) = serve_once(include_str!("../fixtures/http/get_inflation_reward.empty.json"));
|
|
let pool = pool_for_url(url.as_str());
|
|
let rewards = pool
|
|
.get_inflation_reward(&crate::HttpRoleName::new("default"), &[], std::option::Option::None)
|
|
.await
|
|
.expect("empty inflation reward fixture must succeed");
|
|
assert!(rewards.is_empty());
|
|
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_reward_does_not_invent_a_256_address_limit() {
|
|
let (url, handle) = serve_once(include_str!("../fixtures/http/get_inflation_reward.many_nulls.json"));
|
|
let pool = pool_for_url(url.as_str());
|
|
let address = inflation_reward_fixture_pubkey("11111111111111111111111111111111");
|
|
let addresses = std::vec![address; 300];
|
|
let rewards = pool
|
|
.get_inflation_reward(&crate::HttpRoleName::new("default"), addresses.as_slice(), std::option::Option::None)
|
|
.await
|
|
.expect("300-address inflation reward fixture must succeed without local cardinality cap");
|
|
assert_eq!(rewards.len(), 300);
|
|
assert!(rewards.iter().all(std::option::Option::is_none));
|
|
let request = handle.join().expect("fixture server must join");
|
|
let body = request_body(request.as_str());
|
|
assert_eq!(body["params"][0].as_array().expect("address parameter must be an array").len(), 300);
|
|
}
|
|
|
|
#[tokio::test(flavor = "current_thread")]
|
|
async fn typed_get_inflation_reward_rejects_processed_commitment_before_io() {
|
|
let role = crate::HttpRoleName::new("default");
|
|
let pool = pool_for_url("http://127.0.0.1:1");
|
|
let address = inflation_reward_fixture_pubkey("11111111111111111111111111111111");
|
|
let config = crate::SolanaInflationRewardConfig::new(
|
|
std::option::Option::Some(912),
|
|
std::option::Option::Some(crate::SolanaCommitment::Processed),
|
|
std::option::Option::None,
|
|
);
|
|
let result = pool.get_inflation_reward(&role, &[address], std::option::Option::Some(&config)).await;
|
|
let error = result.expect_err("processed inflation-reward commitment must fail before I/O");
|
|
assert_eq!(error.code(), crate::ERROR_CODE_INVALID_RPC_PARAMETERS);
|
|
assert_eq!(error.context()[1].key(), "commitment");
|
|
assert_eq!(error.context()[1].value(), "processed");
|
|
}
|
|
|
|
#[tokio::test(flavor = "current_thread")]
|
|
async fn typed_get_inflation_reward_rejects_response_cardinality_mismatch() {
|
|
let (url, handle) = serve_once(include_str!("../fixtures/http/get_inflation_reward.single_null.json"));
|
|
let pool = pool_for_url(url.as_str());
|
|
let first = inflation_reward_fixture_pubkey("11111111111111111111111111111111");
|
|
let second = inflation_reward_fixture_pubkey("Vote111111111111111111111111111111111111111");
|
|
let result = pool.get_inflation_reward(&crate::HttpRoleName::new("default"), &[first, second], std::option::Option::None).await;
|
|
let error = result.expect_err("inflation reward response count mismatch must fail typed decoding");
|
|
assert_eq!(error.code(), crate::ERROR_CODE_INVALID_RESPONSE);
|
|
assert_eq!(error.context()[1].key(), "expected_count");
|
|
assert_eq!(error.context()[1].value(), "2");
|
|
assert_eq!(error.context()[2].key(), "actual_count");
|
|
assert_eq!(error.context()[2].value(), "1");
|
|
handle.join().expect("fixture server must join");
|
|
}
|
|
|
|
#[tokio::test(flavor = "current_thread")]
|
|
async fn typed_get_inflation_reward_preserves_min_context_slot_rpc_error() {
|
|
let (url, handle) = serve_once(include_str!("../fixtures/http/get_inflation_reward.error_min_context.json"));
|
|
let pool = pool_for_url(url.as_str());
|
|
let address = inflation_reward_fixture_pubkey("11111111111111111111111111111111");
|
|
let config = crate::SolanaInflationRewardConfig::new(
|
|
std::option::Option::Some(912),
|
|
std::option::Option::Some(crate::SolanaCommitment::Confirmed),
|
|
std::option::Option::Some(431_500_000),
|
|
);
|
|
let result = pool.get_inflation_reward(&crate::HttpRoleName::new("default"), &[address], std::option::Option::Some(&config)).await;
|
|
let error = result.expect_err("inflation reward min-context 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_inflation_reward_preserves_epoch_rewards_period_active_rpc_error() {
|
|
let (url, handle) = serve_once(include_str!("../fixtures/http/get_inflation_reward.error_epoch_rewards_active.json"));
|
|
let pool = pool_for_url(url.as_str());
|
|
let address = inflation_reward_fixture_pubkey("11111111111111111111111111111111");
|
|
let result = pool.get_inflation_reward(&crate::HttpRoleName::new("default"), &[address], std::option::Option::None).await;
|
|
let error = result.expect_err("active epoch-rewards RPC error must propagate");
|
|
assert_eq!(error.code(), crate::ERROR_CODE_RPC_APPLICATION_ERROR);
|
|
handle.join().expect("fixture server must join");
|
|
}
|