// file: crates/ksp-onchain-transport-lib/tests/public_api.rs
// version: 38

//! Integration tests for the public `ksp-onchain-transport-lib` consumer contract.

#[test]
fn public_settings_contract_is_constructible_without_config_dependency() {
    let url = ksp_onchain_transport_lib::HttpEndpointUrl::parse("https://api.devnet.solana.com").expect("public URL parser must accept Devnet endpoint");
    let role = ksp_onchain_transport_lib::HttpEndpointRoleSettings::new(
        ksp_onchain_transport_lib::HttpRoleName::new("default"),
        true,
        std::vec![ksp_onchain_transport_lib::HttpRequestKind::wildcard()],
        100,
        ksp_onchain_transport_lib::HttpRoleLimits::new(
            std::option::Option::None,
            std::option::Option::None,
            std::option::Option::None,
            std::option::Option::None,
        ),
    );
    let endpoint = ksp_onchain_transport_lib::HttpEndpointSettings::new(
        "solana_devnet_public",
        true,
        ksp_onchain_transport_lib::HttpProviderName::new("solana-public"),
        ksp_onchain_transport_lib::HttpClusterName::new("devnet"),
        url,
        std::time::Duration::from_secs(5),
        std::time::Duration::from_secs(15),
        std::option::Option::Some(8),
        std::vec![role],
    );
    let settings = ksp_onchain_transport_lib::HttpTransportSettings::new(
        std::vec![endpoint],
        ksp_onchain_transport_lib::HttpRetrySettings::new(2, std::time::Duration::from_millis(100), std::time::Duration::from_secs(2)),
    );
    assert!(settings.validate().is_ok());
}

#[test]
fn public_json_rpc_contract_round_trips_foundation_shape() {
    let request = ksp_onchain_transport_lib::JsonRpcRequest::new(1, "getHealth", std::vec![]).expect("public request constructor must succeed");
    let encoded = request.to_json_string().expect("public request must serialize");
    assert!(encoded.contains("\"jsonrpc\":\"2.0\""));
    let response =
        ksp_onchain_transport_lib::parse_json_rpc_response_text(r#"{"jsonrpc":"2.0","result":"ok","id":1}"#, 1).expect("public parser must validate response");
    let result = response.into_result().expect("success response must return result");
    assert_eq!(result, serde_json::json!("ok"));
}

#[test]
fn public_method_registry_exposes_current_and_historical_surfaces() {
    assert_eq!(ksp_onchain_transport_lib::current_http_rpc_methods().len(), 52);
    assert_eq!(ksp_onchain_transport_lib::historical_http_rpc_methods().len(), 14);
    let removed = ksp_onchain_transport_lib::find_http_rpc_method("confirmTransaction").expect("historical method must be discoverable");
    assert_eq!(removed.runtime_status(), ksp_onchain_transport_lib::RpcRuntimeStatus::Removed);
    assert_eq!(removed.ensure_runtime_supported().expect_err("removed method must fail").code(), ksp_onchain_transport_lib::ERROR_CODE_METHOD_REMOVED);
}

#[test]
fn public_error_codes_share_the_core_error_domain() {
    assert_eq!(ksp_onchain_transport_lib::ERROR_CODE_INVALID_SETTINGS.domain(), "onchain_transport");
    assert_eq!(ksp_onchain_transport_lib::ERROR_CODE_RPC_APPLICATION_ERROR.domain(), "onchain_transport");
}

#[test]
fn public_pool_contract_selects_a_standard_method_without_exposing_url() {
    let url = ksp_onchain_transport_lib::HttpEndpointUrl::parse("https://provider.invalid/rpc?token=SECRET-CANARY")
        .expect("public URL parser must accept HTTPS endpoint");
    let role = ksp_onchain_transport_lib::HttpEndpointRoleSettings::new(
        ksp_onchain_transport_lib::HttpRoleName::new("default"),
        true,
        std::vec![ksp_onchain_transport_lib::HttpRequestKind::new("get_balance")],
        10,
        ksp_onchain_transport_lib::HttpRoleLimits::new(
            std::option::Option::None,
            std::option::Option::None,
            std::option::Option::None,
            std::option::Option::None,
        ),
    );
    let endpoint = ksp_onchain_transport_lib::HttpEndpointSettings::new(
        "primary",
        true,
        ksp_onchain_transport_lib::HttpProviderName::new("provider"),
        ksp_onchain_transport_lib::HttpClusterName::new("devnet"),
        url,
        std::time::Duration::from_secs(2),
        std::time::Duration::from_secs(10),
        std::option::Option::Some(8),
        std::vec![role],
    );
    let settings = ksp_onchain_transport_lib::HttpTransportSettings::new(
        std::vec![endpoint],
        ksp_onchain_transport_lib::HttpRetrySettings::new(1, std::time::Duration::from_millis(10), std::time::Duration::from_millis(50)),
    );
    let pool = ksp_onchain_transport_lib::HttpTransportPool::new(settings).expect("public pool constructor must succeed");
    let method = ksp_onchain_transport_lib::find_http_rpc_method("getBalance").expect("audited method must exist");
    let selected = pool.select_for_method(&ksp_onchain_transport_lib::HttpRoleName::new("default"), method).expect("public pool must route audited method");
    assert_eq!(selected.endpoint_name(), "primary");
    let rendered = format!("{pool:?}");
    assert!(!rendered.contains("SECRET-CANARY"));
    assert!(!rendered.contains("provider.invalid"));
}

#[test]
fn public_retry_policy_preserves_no_resend_after_ambiguous_write_dispatch() {
    let method = ksp_onchain_transport_lib::find_http_rpc_method("sendTransaction").expect("sendTransaction must be audited");
    let settings = ksp_onchain_transport_lib::HttpRetrySettings::new(2, std::time::Duration::from_millis(100), std::time::Duration::from_secs(1));
    let decision = ksp_onchain_transport_lib::evaluate_transport_retry(
        method,
        &settings,
        ksp_onchain_transport_lib::HttpRetryCause::Timeout,
        ksp_onchain_transport_lib::HttpDispatchState::DispatchedAmbiguous,
        0,
        std::option::Option::None,
    );
    assert_eq!(decision, ksp_onchain_transport_lib::HttpRetryDecision::Stop);
}

#[tokio::test]
async fn public_async_admission_exposes_bounded_permit_without_endpoint_url() {
    let url = ksp_onchain_transport_lib::HttpEndpointUrl::parse("https://provider.invalid/rpc?token=ASYNC-SECRET-CANARY")
        .expect("public URL parser must accept HTTPS endpoint");
    let role = ksp_onchain_transport_lib::HttpEndpointRoleSettings::new(
        ksp_onchain_transport_lib::HttpRoleName::new("default"),
        true,
        std::vec![ksp_onchain_transport_lib::HttpRequestKind::new("get_balance")],
        10,
        ksp_onchain_transport_lib::HttpRoleLimits::new(
            std::option::Option::None,
            std::option::Option::None,
            std::num::NonZeroU32::new(1),
            std::option::Option::None,
        ),
    );
    let endpoint = ksp_onchain_transport_lib::HttpEndpointSettings::new(
        "primary",
        true,
        ksp_onchain_transport_lib::HttpProviderName::new("provider"),
        ksp_onchain_transport_lib::HttpClusterName::new("devnet"),
        url,
        std::time::Duration::from_secs(2),
        std::time::Duration::from_secs(10),
        std::option::Option::Some(8),
        std::vec![role],
    );
    let settings = ksp_onchain_transport_lib::HttpTransportSettings::new(
        std::vec![endpoint],
        ksp_onchain_transport_lib::HttpRetrySettings::new(1, std::time::Duration::from_millis(10), std::time::Duration::from_millis(50)),
    );
    let pool = ksp_onchain_transport_lib::HttpTransportPool::new(settings).expect("public pool constructor must succeed");
    let method = ksp_onchain_transport_lib::find_http_rpc_method("getBalance").expect("audited method must exist");
    let permit = pool
        .acquire_for_method(&ksp_onchain_transport_lib::HttpRoleName::new("default"), method)
        .await
        .expect("public async admission must acquire capacity");
    assert_eq!(permit.selection().endpoint_name(), "primary");
    assert!(permit.remaining_timeout() > std::time::Duration::ZERO);
    let rendered = format!("{permit:?}");
    assert!(!rendered.contains("ASYNC-SECRET-CANARY"));
    assert!(!rendered.contains("provider.invalid"));
}

#[test]
fn public_typed_canary_contracts_are_available_from_crate_root() {
    let config = ksp_onchain_transport_lib::GetBalanceConfig::new(
        std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Confirmed),
        std::option::Option::Some(42),
    );
    assert_eq!(config.commitment(), std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Confirmed));
    assert_eq!(config.min_context_slot(), std::option::Option::Some(42));
    assert_eq!(ksp_onchain_transport_lib::SolanaNodeHealth::Healthy, ksp_onchain_transport_lib::SolanaNodeHealth::Healthy);
}

#[test]
fn public_pre_002_shared_rpc_types_are_constructible_from_crate_root() {
    let context = ksp_onchain_transport_lib::SolanaContextConfig::new(
        std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Finalized),
        std::option::Option::Some(123),
    );
    assert_eq!(context.commitment(), std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Finalized));
    assert_eq!(context.min_context_slot(), std::option::Option::Some(123));
    let account = ksp_onchain_transport_lib::SolanaAccountInfoConfig::new(
        std::option::Option::Some(ksp_onchain_transport_lib::SolanaAccountEncoding::JsonParsed),
        std::option::Option::None,
        std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Confirmed),
        std::option::Option::None,
    );
    assert_eq!(account.encoding(), std::option::Option::Some(ksp_onchain_transport_lib::SolanaAccountEncoding::JsonParsed));
    let pubkey = "11111111111111111111111111111111".parse::<ksp_core_lib::Pubkey>().expect("fixture pubkey must parse");
    let selector = ksp_onchain_transport_lib::SolanaTokenAccountSelector::Mint(pubkey);
    assert!(matches!(selector, ksp_onchain_transport_lib::SolanaTokenAccountSelector::Mint(_)));
    let vote = ksp_onchain_transport_lib::SolanaVoteAccountsConfig::new(
        std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Finalized),
        std::option::Option::Some(pubkey),
        std::option::Option::Some(true),
        std::option::Option::Some(128),
    );
    assert_eq!(vote.vote_pubkey(), std::option::Option::Some(&pubkey));
}

#[test]
fn public_pre_003_account_wrappers_are_available_from_crate_root() {
    let _get_account_info = ksp_onchain_transport_lib::HttpTransportPool::get_account_info;
    let _get_largest_accounts = ksp_onchain_transport_lib::HttpTransportPool::get_largest_accounts;
    let _get_minimum_balance_for_rent_exemption = ksp_onchain_transport_lib::HttpTransportPool::get_minimum_balance_for_rent_exemption;
    let _get_multiple_accounts = ksp_onchain_transport_lib::HttpTransportPool::get_multiple_accounts;
    let _get_program_accounts = ksp_onchain_transport_lib::HttpTransportPool::get_program_accounts;
    assert_eq!(ksp_onchain_transport_lib::ERROR_CODE_INVALID_RPC_PARAMETERS.domain(), "onchain_transport");
    assert_eq!(ksp_onchain_transport_lib::ERROR_CODE_INVALID_RPC_PARAMETERS.code(), "invalid_rpc_parameters");
}

#[test]
fn public_pre_004_token_wrappers_are_available_from_crate_root() {
    let _get_token_account_balance = ksp_onchain_transport_lib::HttpTransportPool::get_token_account_balance;
    let _get_token_accounts_by_delegate = ksp_onchain_transport_lib::HttpTransportPool::get_token_accounts_by_delegate;
    let _get_token_accounts_by_owner = ksp_onchain_transport_lib::HttpTransportPool::get_token_accounts_by_owner;
    let _get_token_largest_accounts = ksp_onchain_transport_lib::HttpTransportPool::get_token_largest_accounts;
    let _get_token_supply = ksp_onchain_transport_lib::HttpTransportPool::get_token_supply;
    let mint = "11111111111111111111111111111111".parse::<ksp_core_lib::Pubkey>().expect("fixture pubkey must parse");
    let selector = ksp_onchain_transport_lib::SolanaTokenAccountSelector::Mint(mint);
    assert!(matches!(selector, ksp_onchain_transport_lib::SolanaTokenAccountSelector::Mint(_)));
}

#[test]
fn public_pre_005_simple_cluster_wrappers_are_available_from_crate_root() {
    let _get_cluster_nodes = ksp_onchain_transport_lib::HttpTransportPool::get_cluster_nodes;
    let _get_epoch_info = ksp_onchain_transport_lib::HttpTransportPool::get_epoch_info;
    let _get_epoch_schedule = ksp_onchain_transport_lib::HttpTransportPool::get_epoch_schedule;
    let _get_highest_snapshot_slot = ksp_onchain_transport_lib::HttpTransportPool::get_highest_snapshot_slot;
    let _get_identity = ksp_onchain_transport_lib::HttpTransportPool::get_identity;
    let _get_max_retransmit_slot = ksp_onchain_transport_lib::HttpTransportPool::get_max_retransmit_slot;
    let _get_max_shred_insert_slot = ksp_onchain_transport_lib::HttpTransportPool::get_max_shred_insert_slot;
}

#[test]
fn public_pre_006_remaining_cluster_wrappers_are_available_from_crate_root() {
    let _get_leader_schedule = ksp_onchain_transport_lib::HttpTransportPool::get_leader_schedule;
    let _get_slot = ksp_onchain_transport_lib::HttpTransportPool::get_slot;
    let _get_slot_leader = ksp_onchain_transport_lib::HttpTransportPool::get_slot_leader;
    let _get_slot_leaders = ksp_onchain_transport_lib::HttpTransportPool::get_slot_leaders;
    let _get_vote_accounts = ksp_onchain_transport_lib::HttpTransportPool::get_vote_accounts;
    let request = ksp_onchain_transport_lib::SolanaLeaderScheduleRequest::default();
    assert!(matches!(request, ksp_onchain_transport_lib::SolanaLeaderScheduleRequest::CurrentEpoch(std::option::Option::None)));
}

#[test]
fn public_transaction_pre_002_shared_types_are_constructible_from_crate_root() {
    let get_transaction = ksp_onchain_transport_lib::SolanaGetTransactionConfig::new(
        std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Confirmed),
        std::option::Option::Some(ksp_onchain_transport_lib::SolanaTransactionEncoding::JsonParsed),
        std::option::Option::Some(0),
    );
    assert_eq!(get_transaction.max_supported_transaction_version(), std::option::Option::Some(0));
    let send = ksp_onchain_transport_lib::SolanaSendTransactionConfig::new(
        std::option::Option::Some(false),
        std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Processed),
        std::option::Option::Some(ksp_onchain_transport_lib::SolanaTransactionBinaryEncoding::Base64),
        std::option::Option::Some(3),
        std::option::Option::None,
    );
    assert_eq!(send.max_retries(), std::option::Option::Some(3));
    let pagination = ksp_onchain_transport_lib::SolanaSignaturesForAddressConfig::new(
        std::option::Option::Some("before".to_owned()),
        std::option::Option::None,
        std::option::Option::Some(10),
        std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Finalized),
        std::option::Option::None,
    );
    assert_eq!(pagination.limit(), std::option::Option::Some(10));
    assert!(ksp_onchain_transport_lib::SolanaWireField::<u64>::Omitted.is_omitted());
}

#[test]
fn public_transaction_pre_003_read_wrappers_are_available_from_crate_root() {
    let _get_fee_for_message = ksp_onchain_transport_lib::HttpTransportPool::get_fee_for_message;
    let _get_latest_blockhash = ksp_onchain_transport_lib::HttpTransportPool::get_latest_blockhash;
    let _get_transaction_count = ksp_onchain_transport_lib::HttpTransportPool::get_transaction_count;
    let _is_blockhash_valid = ksp_onchain_transport_lib::HttpTransportPool::is_blockhash_valid;
}

#[test]
fn public_transaction_pre_004_additional_read_wrappers_are_available_from_crate_root() {
    let _get_recent_prioritization_fees = ksp_onchain_transport_lib::HttpTransportPool::get_recent_prioritization_fees;
    let _get_signatures_for_address = ksp_onchain_transport_lib::HttpTransportPool::get_signatures_for_address;
    let _get_signature_statuses = ksp_onchain_transport_lib::HttpTransportPool::get_signature_statuses;
}

#[allow(deprecated)]
#[test]
fn public_transaction_pre_005_get_transaction_complete_request_forms_are_available_from_crate_root() {
    let _get_transaction = ksp_onchain_transport_lib::HttpTransportPool::get_transaction;
    let _get_transaction_legacy = ksp_onchain_transport_lib::HttpTransportPool::get_transaction_legacy;
    let config = ksp_onchain_transport_lib::SolanaGetTransactionConfig::new(
        std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Confirmed),
        std::option::Option::Some(ksp_onchain_transport_lib::SolanaTransactionEncoding::JsonParsed),
        std::option::Option::Some(0),
    );
    assert_eq!(config.commitment(), std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Confirmed));
    assert_eq!(config.encoding(), std::option::Option::Some(ksp_onchain_transport_lib::SolanaTransactionEncoding::JsonParsed));
    assert_eq!(config.max_supported_transaction_version(), std::option::Option::Some(0));
}

#[test]
fn public_transaction_pre_006_write_wrappers_and_complete_configs_are_available_from_crate_root() {
    let _request_airdrop = ksp_onchain_transport_lib::HttpTransportPool::request_airdrop;
    let _send_transaction = ksp_onchain_transport_lib::HttpTransportPool::send_transaction;
    let airdrop = ksp_onchain_transport_lib::SolanaRequestAirdropConfig::new(
        std::option::Option::Some("recent-blockhash".to_owned()),
        std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Confirmed),
    );
    assert_eq!(airdrop.recent_blockhash(), std::option::Option::Some("recent-blockhash"));
    let send = ksp_onchain_transport_lib::SolanaSendTransactionConfig::new(
        std::option::Option::Some(false),
        std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Processed),
        std::option::Option::Some(ksp_onchain_transport_lib::SolanaTransactionBinaryEncoding::Base64),
        std::option::Option::Some(5),
        std::option::Option::Some(431_000_000),
    );
    assert_eq!(send.encoding(), std::option::Option::Some(ksp_onchain_transport_lib::SolanaTransactionBinaryEncoding::Base64));
    assert_eq!(send.max_retries(), std::option::Option::Some(5));
    assert_eq!(send.min_context_slot(), std::option::Option::Some(431_000_000));
}

#[test]
fn public_transaction_pre_007_simulation_wrapper_and_complete_config_are_available_from_crate_root() {
    let _simulate_transaction = ksp_onchain_transport_lib::HttpTransportPool::simulate_transaction;
    let address = "11111111111111111111111111111111".parse::<ksp_core_lib::Pubkey>().expect("fixture pubkey must parse");
    let accounts = ksp_onchain_transport_lib::SolanaSimulationAccountsConfig::new(
        std::option::Option::Some(ksp_onchain_transport_lib::SolanaAccountEncoding::Base64Zstd),
        std::vec![address],
    );
    let config = ksp_onchain_transport_lib::SolanaSimulateTransactionConfig::new(
        std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Processed),
        std::option::Option::Some(ksp_onchain_transport_lib::SolanaTransactionBinaryEncoding::Base64),
        std::option::Option::Some(false),
        std::option::Option::Some(true),
        std::option::Option::Some(431_000_000),
        std::option::Option::Some(true),
        std::option::Option::Some(accounts),
    );
    assert_eq!(config.commitment(), std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Processed));
    assert_eq!(config.encoding(), std::option::Option::Some(ksp_onchain_transport_lib::SolanaTransactionBinaryEncoding::Base64));
    assert_eq!(config.sig_verify(), std::option::Option::Some(true));
    assert_eq!(
        config.accounts().and_then(ksp_onchain_transport_lib::SolanaSimulationAccountsConfig::encoding),
        std::option::Option::Some(ksp_onchain_transport_lib::SolanaAccountEncoding::Base64Zstd),
    );
}

#[test]
fn public_v0_2_4_pre_002_blocks_economics_types_are_available_from_crate_root() {
    let block = ksp_onchain_transport_lib::SolanaGetBlockConfig::new(
        std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Confirmed),
        std::option::Option::Some(ksp_onchain_transport_lib::SolanaTransactionEncoding::Json),
        std::option::Option::Some(ksp_onchain_transport_lib::SolanaTransactionDetails::Full),
        std::option::Option::Some(1),
        std::option::Option::Some(true),
    );
    assert_eq!(block.max_supported_transaction_version(), std::option::Option::Some(1));
    let range = ksp_onchain_transport_lib::SolanaBlockProductionRange::new(100, std::option::Option::Some(200));
    assert_eq!(range.last_slot(), std::option::Option::Some(200));
    let production_config = ksp_onchain_transport_lib::SolanaBlockProductionConfig::new(
        std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Confirmed),
        std::option::Option::None,
        std::option::Option::Some(range),
    );
    assert_eq!(production_config.range().map(ksp_onchain_transport_lib::SolanaBlockProductionRange::first_slot), std::option::Option::Some(100));
    let inflation = ksp_onchain_transport_lib::SolanaInflationRewardConfig::new(
        std::option::Option::Some(812),
        std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Finalized),
        std::option::Option::Some(430_000_000),
    );
    assert_eq!(inflation.epoch(), std::option::Option::Some(812));
    let supply = ksp_onchain_transport_lib::SolanaSupplyConfig::new(std::option::Option::None, std::option::Option::Some(false));
    assert_eq!(supply.exclude_non_circulating_accounts_list(), std::option::Option::Some(false));
    let _block_commitment: std::option::Option<ksp_onchain_transport_lib::SolanaBlockCommitment> = std::option::Option::None;
    let _block_production: std::option::Option<ksp_onchain_transport_lib::SolanaBlockProduction> = std::option::Option::None;
    let _block_production_result_range: std::option::Option<ksp_onchain_transport_lib::SolanaBlockProductionResultRange> = std::option::Option::None;
    let _block_reward: std::option::Option<ksp_onchain_transport_lib::SolanaBlockReward> = std::option::Option::None;
    let _block_transaction: std::option::Option<ksp_onchain_transport_lib::SolanaBlockTransaction> = std::option::Option::None;
    let _confirmed_block: std::option::Option<ksp_onchain_transport_lib::SolanaConfirmedBlock> = std::option::Option::None;
    let _performance_sample: std::option::Option<ksp_onchain_transport_lib::SolanaPerformanceSample> = std::option::Option::None;
    let _governor: std::option::Option<ksp_onchain_transport_lib::SolanaInflationGovernor> = std::option::Option::None;
    let _rate: std::option::Option<ksp_onchain_transport_lib::SolanaInflationRate> = std::option::Option::None;
    let _reward: std::option::Option<ksp_onchain_transport_lib::SolanaInflationReward> = std::option::Option::None;
    let _supply: std::option::Option<ksp_onchain_transport_lib::SolanaSupply> = std::option::Option::None;
}

#[test]
fn public_v0_2_4_pre_003_simple_block_wrappers_are_available_from_crate_root() {
    let _get_block_commitment = ksp_onchain_transport_lib::HttpTransportPool::get_block_commitment;
    let _get_block_height = ksp_onchain_transport_lib::HttpTransportPool::get_block_height;
    let _get_block_time = ksp_onchain_transport_lib::HttpTransportPool::get_block_time;
    let _get_first_available_block = ksp_onchain_transport_lib::HttpTransportPool::get_first_available_block;
    let _minimum_ledger_slot = ksp_onchain_transport_lib::HttpTransportPool::minimum_ledger_slot;
}

#[test]
fn public_v0_2_4_pre_004_range_and_performance_wrappers_are_available_from_crate_root() {
    let _get_blocks = ksp_onchain_transport_lib::HttpTransportPool::get_blocks;
    let _get_blocks_with_limit = ksp_onchain_transport_lib::HttpTransportPool::get_blocks_with_limit;
    let _get_recent_performance_samples = ksp_onchain_transport_lib::HttpTransportPool::get_recent_performance_samples;
}

#[test]
fn public_v0_2_4_pre_005_block_production_wrapper_is_available_from_crate_root() {
    let identity = "11111111111111111111111111111111".parse::<ksp_core_lib::Pubkey>().expect("public fixture identity must parse");
    let range = ksp_onchain_transport_lib::SolanaBlockProductionRange::new(10, std::option::Option::Some(20));
    let config = ksp_onchain_transport_lib::SolanaBlockProductionConfig::new(
        std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Finalized),
        std::option::Option::Some(identity),
        std::option::Option::Some(range),
    );
    assert_eq!(config.identity(), std::option::Option::Some(&identity));
    assert_eq!(config.range().expect("public range must exist").last_slot(), std::option::Option::Some(20));
    let _method = ksp_onchain_transport_lib::HttpTransportPool::get_block_production;
}

#[allow(deprecated)]
#[test]
fn public_v0_2_4_pre_006_get_block_complete_request_forms_are_available_from_crate_root() {
    let _get_block = ksp_onchain_transport_lib::HttpTransportPool::get_block;
    let _get_block_legacy = ksp_onchain_transport_lib::HttpTransportPool::get_block_legacy;
    let config = ksp_onchain_transport_lib::SolanaGetBlockConfig::new(
        std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Confirmed),
        std::option::Option::Some(ksp_onchain_transport_lib::SolanaTransactionEncoding::JsonParsed),
        std::option::Option::Some(ksp_onchain_transport_lib::SolanaTransactionDetails::Accounts),
        std::option::Option::Some(1),
        std::option::Option::Some(true),
    );
    assert_eq!(config.commitment(), std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Confirmed));
    assert_eq!(config.encoding(), std::option::Option::Some(ksp_onchain_transport_lib::SolanaTransactionEncoding::JsonParsed));
    assert_eq!(config.transaction_details(), std::option::Option::Some(ksp_onchain_transport_lib::SolanaTransactionDetails::Accounts));
    assert_eq!(config.max_supported_transaction_version(), std::option::Option::Some(1));
    assert_eq!(config.rewards(), std::option::Option::Some(true));
}

#[test]
fn public_v0_2_4_pre_007_simple_economics_wrappers_are_available_from_crate_root() {
    let _get_inflation_governor = ksp_onchain_transport_lib::HttpTransportPool::get_inflation_governor;
    let _get_inflation_rate = ksp_onchain_transport_lib::HttpTransportPool::get_inflation_rate;
    let _get_stake_minimum_delegation = ksp_onchain_transport_lib::HttpTransportPool::get_stake_minimum_delegation;
    let _get_supply = ksp_onchain_transport_lib::HttpTransportPool::get_supply;
    let supply_config = ksp_onchain_transport_lib::SolanaSupplyConfig::new(
        std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Processed),
        std::option::Option::Some(false),
    );
    assert_eq!(supply_config.commitment(), std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Processed));
    assert_eq!(supply_config.exclude_non_circulating_accounts_list(), std::option::Option::Some(false));
}

#[test]
fn public_v0_2_4_pre_008_inflation_reward_wrapper_is_available_from_crate_root() {
    let _get_inflation_reward = ksp_onchain_transport_lib::HttpTransportPool::get_inflation_reward;
    let config = ksp_onchain_transport_lib::SolanaInflationRewardConfig::new(
        std::option::Option::Some(912),
        std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Confirmed),
        std::option::Option::Some(431_000_000),
    );
    assert_eq!(config.epoch(), std::option::Option::Some(912));
    assert_eq!(config.commitment(), std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Confirmed));
    assert_eq!(config.min_context_slot(), std::option::Option::Some(431_000_000));
}

#[allow(deprecated)]
#[test]
fn public_v0_2_4_pre_009_all_52_current_typed_wrappers_and_legacy_forms_are_available_from_crate_root() {
    let _get_account_info = ksp_onchain_transport_lib::HttpTransportPool::get_account_info;
    let _get_balance = ksp_onchain_transport_lib::HttpTransportPool::get_balance;
    let _get_largest_accounts = ksp_onchain_transport_lib::HttpTransportPool::get_largest_accounts;
    let _get_minimum_balance_for_rent_exemption = ksp_onchain_transport_lib::HttpTransportPool::get_minimum_balance_for_rent_exemption;
    let _get_multiple_accounts = ksp_onchain_transport_lib::HttpTransportPool::get_multiple_accounts;
    let _get_program_accounts = ksp_onchain_transport_lib::HttpTransportPool::get_program_accounts;
    let _get_token_account_balance = ksp_onchain_transport_lib::HttpTransportPool::get_token_account_balance;
    let _get_token_accounts_by_delegate = ksp_onchain_transport_lib::HttpTransportPool::get_token_accounts_by_delegate;
    let _get_token_accounts_by_owner = ksp_onchain_transport_lib::HttpTransportPool::get_token_accounts_by_owner;
    let _get_token_largest_accounts = ksp_onchain_transport_lib::HttpTransportPool::get_token_largest_accounts;
    let _get_token_supply = ksp_onchain_transport_lib::HttpTransportPool::get_token_supply;
    let _get_fee_for_message = ksp_onchain_transport_lib::HttpTransportPool::get_fee_for_message;
    let _get_latest_blockhash = ksp_onchain_transport_lib::HttpTransportPool::get_latest_blockhash;
    let _get_recent_prioritization_fees = ksp_onchain_transport_lib::HttpTransportPool::get_recent_prioritization_fees;
    let _get_signatures_for_address = ksp_onchain_transport_lib::HttpTransportPool::get_signatures_for_address;
    let _get_signature_statuses = ksp_onchain_transport_lib::HttpTransportPool::get_signature_statuses;
    let _get_transaction = ksp_onchain_transport_lib::HttpTransportPool::get_transaction;
    let _get_transaction_count = ksp_onchain_transport_lib::HttpTransportPool::get_transaction_count;
    let _is_blockhash_valid = ksp_onchain_transport_lib::HttpTransportPool::is_blockhash_valid;
    let _request_airdrop = ksp_onchain_transport_lib::HttpTransportPool::request_airdrop;
    let _send_transaction = ksp_onchain_transport_lib::HttpTransportPool::send_transaction;
    let _simulate_transaction = ksp_onchain_transport_lib::HttpTransportPool::simulate_transaction;
    let _get_block = ksp_onchain_transport_lib::HttpTransportPool::get_block;
    let _get_block_commitment = ksp_onchain_transport_lib::HttpTransportPool::get_block_commitment;
    let _get_block_height = ksp_onchain_transport_lib::HttpTransportPool::get_block_height;
    let _get_block_production = ksp_onchain_transport_lib::HttpTransportPool::get_block_production;
    let _get_blocks = ksp_onchain_transport_lib::HttpTransportPool::get_blocks;
    let _get_blocks_with_limit = ksp_onchain_transport_lib::HttpTransportPool::get_blocks_with_limit;
    let _get_block_time = ksp_onchain_transport_lib::HttpTransportPool::get_block_time;
    let _get_first_available_block = ksp_onchain_transport_lib::HttpTransportPool::get_first_available_block;
    let _get_recent_performance_samples = ksp_onchain_transport_lib::HttpTransportPool::get_recent_performance_samples;
    let _minimum_ledger_slot = ksp_onchain_transport_lib::HttpTransportPool::minimum_ledger_slot;
    let _get_cluster_nodes = ksp_onchain_transport_lib::HttpTransportPool::get_cluster_nodes;
    let _get_epoch_info = ksp_onchain_transport_lib::HttpTransportPool::get_epoch_info;
    let _get_epoch_schedule = ksp_onchain_transport_lib::HttpTransportPool::get_epoch_schedule;
    let _get_genesis_hash = ksp_onchain_transport_lib::HttpTransportPool::get_genesis_hash;
    let _get_health = ksp_onchain_transport_lib::HttpTransportPool::get_health;
    let _get_highest_snapshot_slot = ksp_onchain_transport_lib::HttpTransportPool::get_highest_snapshot_slot;
    let _get_identity = ksp_onchain_transport_lib::HttpTransportPool::get_identity;
    let _get_leader_schedule = ksp_onchain_transport_lib::HttpTransportPool::get_leader_schedule;
    let _get_max_retransmit_slot = ksp_onchain_transport_lib::HttpTransportPool::get_max_retransmit_slot;
    let _get_max_shred_insert_slot = ksp_onchain_transport_lib::HttpTransportPool::get_max_shred_insert_slot;
    let _get_slot = ksp_onchain_transport_lib::HttpTransportPool::get_slot;
    let _get_slot_leader = ksp_onchain_transport_lib::HttpTransportPool::get_slot_leader;
    let _get_slot_leaders = ksp_onchain_transport_lib::HttpTransportPool::get_slot_leaders;
    let _get_version = ksp_onchain_transport_lib::HttpTransportPool::get_version;
    let _get_vote_accounts = ksp_onchain_transport_lib::HttpTransportPool::get_vote_accounts;
    let _get_inflation_governor = ksp_onchain_transport_lib::HttpTransportPool::get_inflation_governor;
    let _get_inflation_rate = ksp_onchain_transport_lib::HttpTransportPool::get_inflation_rate;
    let _get_inflation_reward = ksp_onchain_transport_lib::HttpTransportPool::get_inflation_reward;
    let _get_stake_minimum_delegation = ksp_onchain_transport_lib::HttpTransportPool::get_stake_minimum_delegation;
    let _get_supply = ksp_onchain_transport_lib::HttpTransportPool::get_supply;
    let _get_block_legacy = ksp_onchain_transport_lib::HttpTransportPool::get_block_legacy;
    let _get_transaction_legacy = ksp_onchain_transport_lib::HttpTransportPool::get_transaction_legacy;
}

#[test]
fn public_v0_2_7_pre_002_websocket_settings_and_lifecycle_contracts_are_available_from_crate_root() {
    let url = ksp_onchain_transport_lib::WsEndpointUrl::parse("wss://api.devnet.solana.com").expect("public WebSocket URL fixture must parse");
    let session_settings = ksp_onchain_transport_lib::WsSessionSettings::default();
    let endpoint = ksp_onchain_transport_lib::WsEndpointSettings::new(
        "devnet_public",
        true,
        ksp_onchain_transport_lib::WsProviderName::new("solana-public"),
        ksp_onchain_transport_lib::WsClusterName::new("devnet"),
        ksp_onchain_transport_lib::WsProtocolKind::SolanaStandard,
        url,
        session_settings,
    );
    let settings = ksp_onchain_transport_lib::WsTransportSettings::new(std::vec![endpoint]);
    assert!(settings.validate().is_ok());
    assert_eq!(settings.endpoints()[0].protocol(), ksp_onchain_transport_lib::WsProtocolKind::SolanaStandard);
    let session_id = ksp_onchain_transport_lib::WsSessionId::new(std::num::NonZeroU64::new(1).expect("public test ID must be non-zero"));
    let subscription_id = ksp_onchain_transport_lib::WsSubscriptionId::new(std::num::NonZeroU64::new(2).expect("public test ID must be non-zero"));
    assert_eq!(session_id.get(), 1);
    assert_eq!(subscription_id.get(), 2);
    assert_eq!(
        ksp_onchain_transport_lib::WsSessionState::Reconnecting { attempt: 1 },
        ksp_onchain_transport_lib::WsSessionState::Reconnecting { attempt: 1 }
    );
    assert_eq!(ksp_onchain_transport_lib::WsSubscriptionKind::Slot.as_str(), "slot");
    assert_eq!(ksp_onchain_transport_lib::WsSubscriptionState::Requested, ksp_onchain_transport_lib::WsSubscriptionState::Requested);
}

#[test]
fn public_v0_2_7_pre_004_physical_websocket_session_contract_is_available_from_crate_root() {
    let type_name = std::any::type_name::<ksp_onchain_transport_lib::WsSession>();
    assert!(type_name.ends_with("WsSession"));
    assert_eq!(ksp_onchain_transport_lib::ERROR_CODE_WS_BACKPRESSURE_OVERFLOW.code(), "ws_backpressure_overflow");
    assert_eq!(ksp_onchain_transport_lib::ERROR_CODE_WS_CONNECTION_FAILED.code(), "ws_connection_failed");
    assert_eq!(ksp_onchain_transport_lib::ERROR_CODE_WS_PROTOCOL_ERROR.code(), "ws_protocol_error");
    assert_eq!(ksp_onchain_transport_lib::ERROR_CODE_WS_SESSION_CLOSED.code(), "ws_session_closed");
}

#[test]
fn public_v0_2_7_pre_005_bounded_websocket_close_contract_is_available_from_crate_root() {
    let _close = ksp_onchain_transport_lib::WsSession::close;
    assert_eq!(ksp_onchain_transport_lib::WsSessionState::Closing, ksp_onchain_transport_lib::WsSessionState::Closing);
    assert_eq!(ksp_onchain_transport_lib::WsSessionState::Closed, ksp_onchain_transport_lib::WsSessionState::Closed);
}

#[test]
fn public_v0_2_7_pre_006_typed_websocket_subscription_handle_is_available_from_crate_root() {
    let type_name = std::any::type_name::<ksp_onchain_transport_lib::WsSubscription<serde_json::Value>>();
    assert!(type_name.contains("WsSubscription"));
    let _id = ksp_onchain_transport_lib::WsSubscription::<serde_json::Value>::id;
    let _kind = ksp_onchain_transport_lib::WsSubscription::<serde_json::Value>::kind;
    let _state = ksp_onchain_transport_lib::WsSubscription::<serde_json::Value>::state;
    let _recv = ksp_onchain_transport_lib::WsSubscription::<serde_json::Value>::recv;
    let _unsubscribe = ksp_onchain_transport_lib::WsSubscription::<serde_json::Value>::unsubscribe;
}

#[test]
fn public_v0_2_7_pre_008_backpressure_observability_contract_is_available_from_crate_root() {
    let _terminal_error = ksp_onchain_transport_lib::WsSubscription::<serde_json::Value>::terminal_error_code;
    let _snapshot_terminal_error = ksp_onchain_transport_lib::WsSubscriptionSnapshot::terminal_error_code;
    let _overflow_count = ksp_onchain_transport_lib::WsSessionSnapshot::overflow_count;
    assert_eq!(ksp_onchain_transport_lib::ERROR_CODE_WS_BACKPRESSURE_OVERFLOW.code(), "ws_backpressure_overflow");
}

#[test]
fn public_v0_2_7_pre_009_stable_websocket_lot_a_wrappers_and_dtos_are_available_from_crate_root() {
    let _account_subscribe = ksp_onchain_transport_lib::WsSession::account_subscribe;
    let _program_subscribe = ksp_onchain_transport_lib::WsSession::program_subscribe;
    let _logs_subscribe = ksp_onchain_transport_lib::WsSession::logs_subscribe;
    let account_config = ksp_onchain_transport_lib::SolanaAccountSubscribeConfig::new(
        std::option::Option::Some(ksp_onchain_transport_lib::SolanaAccountEncoding::Base64),
        std::option::Option::Some(ksp_onchain_transport_lib::SolanaDataSliceConfig::new(0, 32)),
        std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Confirmed),
    );
    assert_eq!(account_config.commitment(), std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Confirmed));
    let program_config = ksp_onchain_transport_lib::SolanaProgramSubscribeConfig::new(
        account_config,
        std::vec![ksp_onchain_transport_lib::SolanaProgramAccountFilter::DataSize(80)],
        std::option::Option::Some(true),
    );
    assert_eq!(program_config.with_context(), std::option::Option::Some(true));
    let mention = "11111111111111111111111111111111".parse::<ksp_core_lib::Pubkey>().expect("public logs mention fixture must parse");
    let filter = ksp_onchain_transport_lib::SolanaLogsSubscribeFilter::Mentions(mention);
    let filter_name = std::any::type_name_of_val(&filter);
    assert!(filter_name.ends_with("SolanaLogsSubscribeFilter"));
    let _program_notification = std::any::type_name::<ksp_onchain_transport_lib::SolanaProgramNotification>();
    let _logs_notification = std::any::type_name::<ksp_onchain_transport_lib::SolanaLogsNotification>();
}

#[test]
fn public_v0_2_7_pre_010_stable_websocket_lot_b_wrappers_and_dtos_are_available_from_crate_root() {
    let _signature_subscribe = ksp_onchain_transport_lib::WsSession::signature_subscribe;
    let _slot_subscribe = ksp_onchain_transport_lib::WsSession::slot_subscribe;
    let _root_subscribe = ksp_onchain_transport_lib::WsSession::root_subscribe;
    let signature_config = ksp_onchain_transport_lib::SolanaSignatureSubscribeConfig::new(
        std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Finalized),
        std::option::Option::Some(true),
    );
    assert_eq!(signature_config.commitment(), std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Finalized));
    assert_eq!(signature_config.enable_received_notification(), std::option::Option::Some(true));
    let terminal = ksp_onchain_transport_lib::SolanaSignatureNotification::Processed { err: std::option::Option::None };
    assert!(terminal.is_terminal());
    assert!(terminal.err().is_none());
    let _slot_notification = std::any::type_name::<ksp_onchain_transport_lib::SolanaSlotNotification>();
}

#[test]
fn public_v0_2_7_pre_011_unstable_websocket_wrappers_and_dtos_are_available_from_crate_root() {
    let _block_subscribe = ksp_onchain_transport_lib::WsSession::block_subscribe;
    let _slots_updates_subscribe = ksp_onchain_transport_lib::WsSession::slots_updates_subscribe;
    let _vote_subscribe = ksp_onchain_transport_lib::WsSession::vote_subscribe;
    let pubkey = "11111111111111111111111111111111".parse::<ksp_core_lib::Pubkey>().expect("fixture pubkey must parse");
    let filter = ksp_onchain_transport_lib::SolanaBlockSubscribeFilter::MentionsAccountOrProgram(pubkey);
    assert!(matches!(filter, ksp_onchain_transport_lib::SolanaBlockSubscribeFilter::MentionsAccountOrProgram(_)));
    let config = ksp_onchain_transport_lib::SolanaBlockSubscribeConfig::new(
        std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Confirmed),
        std::option::Option::Some(ksp_onchain_transport_lib::SolanaTransactionEncoding::Base64),
        std::option::Option::Some(ksp_onchain_transport_lib::SolanaTransactionDetails::Full),
        std::option::Option::Some(0),
        std::option::Option::Some(true),
    );
    assert_eq!(config.commitment(), std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Confirmed));
    assert_eq!(config.show_rewards(), std::option::Option::Some(true));
    let _block_notification = std::any::type_name::<ksp_onchain_transport_lib::SolanaBlockNotification>();
    let _slot_update = std::any::type_name::<ksp_onchain_transport_lib::SolanaSlotUpdate>();
    let _slot_update_stats = std::any::type_name::<ksp_onchain_transport_lib::SolanaSlotUpdateStats>();
    let _vote_notification = std::any::type_name::<ksp_onchain_transport_lib::SolanaVoteNotification>();
}

#[test]
fn public_v0_2_7_pre_012_complete_standard_websocket_surface_is_available_from_crate_root() {
    let _account = ksp_onchain_transport_lib::WsSession::account_subscribe;
    let _block = ksp_onchain_transport_lib::WsSession::block_subscribe;
    let _logs = ksp_onchain_transport_lib::WsSession::logs_subscribe;
    let _program = ksp_onchain_transport_lib::WsSession::program_subscribe;
    let _root = ksp_onchain_transport_lib::WsSession::root_subscribe;
    let _signature = ksp_onchain_transport_lib::WsSession::signature_subscribe;
    let _slot = ksp_onchain_transport_lib::WsSession::slot_subscribe;
    let _slots_updates = ksp_onchain_transport_lib::WsSession::slots_updates_subscribe;
    let _vote = ksp_onchain_transport_lib::WsSession::vote_subscribe;
    let _unsubscribe = ksp_onchain_transport_lib::WsSubscription::<serde_json::Value>::unsubscribe;
    let kinds = [
        ksp_onchain_transport_lib::WsSubscriptionKind::Account,
        ksp_onchain_transport_lib::WsSubscriptionKind::Block,
        ksp_onchain_transport_lib::WsSubscriptionKind::Logs,
        ksp_onchain_transport_lib::WsSubscriptionKind::Program,
        ksp_onchain_transport_lib::WsSubscriptionKind::Root,
        ksp_onchain_transport_lib::WsSubscriptionKind::Signature,
        ksp_onchain_transport_lib::WsSubscriptionKind::Slot,
        ksp_onchain_transport_lib::WsSubscriptionKind::SlotsUpdates,
        ksp_onchain_transport_lib::WsSubscriptionKind::Vote,
    ];
    assert_eq!(kinds.len(), 9);
}

#[test]
fn public_v0_2_8_pre_002_protocol_facades_are_available_without_replacing_the_standard_session_contract() {
    assert_eq!(ksp_onchain_transport_lib::WsProtocolKind::SolanaStandard.as_str(), "solana_standard");
    assert_eq!(ksp_onchain_transport_lib::WsProtocolKind::HeliusLaserStream.as_str(), "helius_laserstream");
    let _historical_connect = ksp_onchain_transport_lib::WsSession::connect;
    let _standard_connect = ksp_onchain_transport_lib::SolanaStandardWsSession::connect;
    let _standard_close = ksp_onchain_transport_lib::SolanaStandardWsSession::close;
    let _standard_snapshot = ksp_onchain_transport_lib::SolanaStandardWsSession::snapshot;
    let _standard_account = ksp_onchain_transport_lib::SolanaStandardWsSession::account_subscribe;
    let _standard_block = ksp_onchain_transport_lib::SolanaStandardWsSession::block_subscribe;
    let _standard_logs = ksp_onchain_transport_lib::SolanaStandardWsSession::logs_subscribe;
    let _standard_program = ksp_onchain_transport_lib::SolanaStandardWsSession::program_subscribe;
    let _standard_root = ksp_onchain_transport_lib::SolanaStandardWsSession::root_subscribe;
    let _standard_signature = ksp_onchain_transport_lib::SolanaStandardWsSession::signature_subscribe;
    let _standard_slot = ksp_onchain_transport_lib::SolanaStandardWsSession::slot_subscribe;
    let _standard_slots_updates = ksp_onchain_transport_lib::SolanaStandardWsSession::slots_updates_subscribe;
    let _standard_vote = ksp_onchain_transport_lib::SolanaStandardWsSession::vote_subscribe;
    let _helius_connect = ksp_onchain_transport_lib::HeliusLaserStreamWsSession::connect;
    let _helius_close = ksp_onchain_transport_lib::HeliusLaserStreamWsSession::close;
    let _helius_snapshot = ksp_onchain_transport_lib::HeliusLaserStreamWsSession::snapshot;
}

#[test]
fn public_v0_2_8_pre_003_helius_standard_surface_reuses_shared_typed_contracts() {
    let _account = ksp_onchain_transport_lib::HeliusLaserStreamWsSession::account_subscribe;
    let _program = ksp_onchain_transport_lib::HeliusLaserStreamWsSession::program_subscribe;
    let _logs = ksp_onchain_transport_lib::HeliusLaserStreamWsSession::logs_subscribe;
    let _signature = ksp_onchain_transport_lib::HeliusLaserStreamWsSession::signature_subscribe;
    let _slot = ksp_onchain_transport_lib::HeliusLaserStreamWsSession::slot_subscribe;
    let _root = ksp_onchain_transport_lib::HeliusLaserStreamWsSession::root_subscribe;
    let _shared_account_config = std::any::type_name::<ksp_onchain_transport_lib::SolanaAccountSubscribeConfig>();
    let _shared_program_config = std::any::type_name::<ksp_onchain_transport_lib::SolanaProgramSubscribeConfig>();
    let _shared_logs_filter = std::any::type_name::<ksp_onchain_transport_lib::SolanaLogsSubscribeFilter>();
    let _shared_signature_config = std::any::type_name::<ksp_onchain_transport_lib::SolanaSignatureSubscribeConfig>();
    let _shared_slot_notification = std::any::type_name::<ksp_onchain_transport_lib::SolanaSlotNotification>();
}

#[test]
fn public_v0_2_8_pre_005_helius_transaction_request_contract_is_available_without_live_handle() {
    let account = "11111111111111111111111111111111".parse::<ksp_core_lib::Pubkey>().expect("fixture pubkey must parse");
    let filter = ksp_onchain_transport_lib::HeliusTransactionSubscribeFilter::new(
        std::option::Option::Some(false),
        std::option::Option::Some(false),
        std::option::Option::Some("fixture-signature".to_owned()),
        std::option::Option::Some(std::vec![account]),
        std::option::Option::None,
        std::option::Option::None,
        std::option::Option::Some(ksp_onchain_transport_lib::HeliusTokenAccountsFilter::BalanceChanged),
    );
    let options = ksp_onchain_transport_lib::HeliusTransactionSubscribeOptions::new(
        std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Confirmed),
        std::option::Option::Some(ksp_onchain_transport_lib::HeliusTransactionSubscribeEncoding::JsonParsed),
        std::option::Option::Some(ksp_onchain_transport_lib::SolanaTransactionDetails::Full),
        std::option::Option::Some(false),
        std::option::Option::Some(0),
    );
    let request = ksp_onchain_transport_lib::HeliusTransactionSubscribeRequest::new(filter, std::option::Option::Some(options));
    assert!(request.validate().is_ok());
    assert_eq!(request.filter().token_accounts(), std::option::Option::Some(ksp_onchain_transport_lib::HeliusTokenAccountsFilter::BalanceChanged));
    assert_eq!(
        request.options().and_then(ksp_onchain_transport_lib::HeliusTransactionSubscribeOptions::encoding),
        std::option::Option::Some(ksp_onchain_transport_lib::HeliusTransactionSubscribeEncoding::JsonParsed)
    );
    assert_eq!(ksp_onchain_transport_lib::HeliusTokenAccountsFilter::None.as_str(), "none");
    assert_eq!(ksp_onchain_transport_lib::HeliusTokenAccountsFilter::BalanceChanged.as_str(), "balanceChanged");
    assert_eq!(ksp_onchain_transport_lib::HeliusTokenAccountsFilter::All.as_str(), "all");
}

#[test]
fn public_v0_2_8_pre_006_helius_transaction_live_handle_and_notification_types_are_available() {
    let _subscribe = ksp_onchain_transport_lib::HeliusLaserStreamWsSession::transaction_subscribe;
    let _notification = std::any::type_name::<ksp_onchain_transport_lib::HeliusTransactionNotification>();
    let _full = std::any::type_name::<ksp_onchain_transport_lib::HeliusFullTransactionNotification>();
    let _signature = std::any::type_name::<ksp_onchain_transport_lib::HeliusTransactionSignatureNotification>();
    assert_eq!(ksp_onchain_transport_lib::WsSubscriptionKind::HeliusTransaction.as_str(), "helius_transaction");
}

#[test]
fn public_v0_2_8_pre_009_helius_slots_updates_surface_reuses_shared_typed_contract() {
    let _slots_updates = ksp_onchain_transport_lib::HeliusLaserStreamWsSession::slots_updates_subscribe;
    let _shared_slot_update = std::any::type_name::<ksp_onchain_transport_lib::SolanaSlotUpdate>();
    assert_eq!(ksp_onchain_transport_lib::WsSubscriptionKind::SlotsUpdates.as_str(), "slots_updates");
}