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