763 lines
48 KiB
Rust
763 lines
48 KiB
Rust
// 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");
|
|
}
|