1078 lines
69 KiB
Rust
1078 lines
69 KiB
Rust
// file: crates/ksp-onchain-transport-lib/tests/public_api.rs
|
|
// version: 55
|
|
|
|
//! 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_v0_3_6_pre_004_observed_get_transaction_surface_is_available_from_crate_root() {
|
|
let _get_transaction_observed = ksp_onchain_transport_lib::HttpTransportPool::get_transaction_observed;
|
|
let observed: std::option::Option<
|
|
ksp_onchain_transport_lib::HttpObservedValue<std::option::Option<ksp_onchain_transport_lib::SolanaConfirmedTransaction>>,
|
|
> = std::option::Option::None;
|
|
assert!(observed.is_none());
|
|
}
|
|
|
|
#[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_3_14_pre_003_websocket_snapshot_source_is_available_from_crate_root() {
|
|
let _physical = ksp_onchain_transport_lib::WsSession::snapshot_source;
|
|
let _standard = ksp_onchain_transport_lib::SolanaStandardWsSession::snapshot_source;
|
|
let _helius = ksp_onchain_transport_lib::HeliusLaserStreamWsSession::snapshot_source;
|
|
let _current = ksp_onchain_transport_lib::WsSessionSnapshotSource::current;
|
|
let _wait = ksp_onchain_transport_lib::WsSessionSnapshotSource::wait_for_change;
|
|
assert!(std::any::type_name::<ksp_onchain_transport_lib::WsSessionSnapshotSource>().ends_with("WsSessionSnapshotSource"));
|
|
return;
|
|
}
|
|
|
|
#[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");
|
|
}
|
|
|
|
#[tokio::test(flavor = "current_thread")]
|
|
async fn public_v0_2_9_pre_002_yellowstone_engine_settings_and_lazy_channel_are_available_from_crate_root() {
|
|
let url = ksp_onchain_transport_lib::YellowstoneGrpcEndpointUrl::parse("http://127.0.0.1:10000")
|
|
.expect("public Yellowstone gRPC URL parser must accept HTTP fixture endpoint");
|
|
let session = ksp_onchain_transport_lib::YellowstoneGrpcSessionSettings::default();
|
|
assert!(session.validate().is_ok());
|
|
let endpoint = ksp_onchain_transport_lib::YellowstoneGrpcEndpointSettings::new(
|
|
"fixture",
|
|
true,
|
|
ksp_onchain_transport_lib::YellowstoneGrpcProviderName::new("fixture-provider"),
|
|
ksp_onchain_transport_lib::YellowstoneGrpcClusterName::new("devnet"),
|
|
url,
|
|
session,
|
|
);
|
|
let settings = ksp_onchain_transport_lib::YellowstoneGrpcTransportSettings::new(std::vec![endpoint.clone()]);
|
|
assert!(settings.validate().is_ok());
|
|
let channel = ksp_onchain_transport_lib::YellowstoneGrpcChannel::prepare(&endpoint);
|
|
assert!(channel.is_ok());
|
|
let channel = match channel {
|
|
std::result::Result::Ok(value) => value,
|
|
std::result::Result::Err(_) => return,
|
|
};
|
|
assert_eq!(channel.endpoint_name(), "fixture");
|
|
assert_eq!(channel.provider().as_str(), "fixture-provider");
|
|
assert_eq!(channel.cluster().as_str(), "devnet");
|
|
assert_eq!(ksp_onchain_transport_lib::ERROR_CODE_GRPC_CHANNEL_FAILED.domain(), "onchain_transport");
|
|
assert_eq!(ksp_onchain_transport_lib::ERROR_CODE_GRPC_CHANNEL_FAILED.code(), "grpc_channel_failed");
|
|
}
|
|
|
|
#[test]
|
|
fn public_v0_2_9_pre_003_yellowstone_metadata_and_seven_unary_contracts_are_available_from_crate_root() {
|
|
let public = ksp_onchain_transport_lib::YellowstoneGrpcMetadataEntry::public("x-ksp-public", "fixture");
|
|
assert!(public.is_ok());
|
|
let secret = ksp_onchain_transport_lib::YellowstoneGrpcMetadataEntry::secret("x-ksp-token", "secret");
|
|
assert!(secret.is_ok());
|
|
let replay = ksp_onchain_transport_lib::YellowstoneReplayInfo::new(std::option::Option::Some(1));
|
|
assert_eq!(replay.first_available(), std::option::Option::Some(1));
|
|
let pong = ksp_onchain_transport_lib::YellowstonePong::new(2);
|
|
assert_eq!(pong.count(), 2);
|
|
let latest = ksp_onchain_transport_lib::YellowstoneLatestBlockhash::new(3, "hash".to_owned(), 4);
|
|
assert_eq!(latest.slot(), 3);
|
|
assert_eq!(latest.blockhash(), "hash");
|
|
assert_eq!(latest.last_valid_block_height(), 4);
|
|
assert_eq!(ksp_onchain_transport_lib::YellowstoneBlockHeight::new(5).block_height(), 5);
|
|
assert_eq!(ksp_onchain_transport_lib::YellowstoneSlot::new(6).slot(), 6);
|
|
let validity = ksp_onchain_transport_lib::YellowstoneBlockhashValidity::new(7, true);
|
|
assert_eq!(validity.slot(), 7);
|
|
assert!(validity.valid());
|
|
assert_eq!(ksp_onchain_transport_lib::YellowstoneVersionInfo::new("v".to_owned()).version(), "v");
|
|
let _replay_info = ksp_onchain_transport_lib::SolanaYellowstoneGrpcUnaryClient::subscribe_replay_info;
|
|
let _ping = ksp_onchain_transport_lib::SolanaYellowstoneGrpcUnaryClient::ping;
|
|
let _latest_blockhash = ksp_onchain_transport_lib::SolanaYellowstoneGrpcUnaryClient::get_latest_blockhash;
|
|
let _block_height = ksp_onchain_transport_lib::SolanaYellowstoneGrpcUnaryClient::get_block_height;
|
|
let _slot = ksp_onchain_transport_lib::SolanaYellowstoneGrpcUnaryClient::get_slot;
|
|
async fn call_is_blockhash_valid(
|
|
client: &ksp_onchain_transport_lib::SolanaYellowstoneGrpcUnaryClient,
|
|
) -> ksp_core_lib::Result<ksp_onchain_transport_lib::YellowstoneBlockhashValidity> {
|
|
return client.is_blockhash_valid("fixture-blockhash", std::option::Option::None).await;
|
|
}
|
|
let _is_blockhash_valid = call_is_blockhash_valid;
|
|
let _version = ksp_onchain_transport_lib::SolanaYellowstoneGrpcUnaryClient::get_version;
|
|
assert_eq!(ksp_onchain_transport_lib::ERROR_CODE_GRPC_STATUS.domain(), "onchain_transport");
|
|
assert_eq!(ksp_onchain_transport_lib::ERROR_CODE_GRPC_STATUS.code(), "grpc_status");
|
|
}
|
|
|
|
#[test]
|
|
fn public_v0_2_9_pre_004_yellowstone_subscribe_common_contract_is_available_from_crate_root() {
|
|
let mut request = ksp_onchain_transport_lib::YellowstoneSubscribeRequest::new();
|
|
let account_name = ksp_onchain_transport_lib::YellowstoneSubscribeFilterName::new("accounts").expect("account filter name must validate");
|
|
let slot_name = ksp_onchain_transport_lib::YellowstoneSubscribeFilterName::new("slots").expect("slot filter name must validate");
|
|
let transaction_name = ksp_onchain_transport_lib::YellowstoneSubscribeFilterName::new("transactions").expect("transaction filter name must validate");
|
|
let transaction_status_name =
|
|
ksp_onchain_transport_lib::YellowstoneSubscribeFilterName::new("transaction-status").expect("transaction-status filter name must validate");
|
|
let block_name = ksp_onchain_transport_lib::YellowstoneSubscribeFilterName::new("blocks").expect("block filter name must validate");
|
|
let block_meta_name = ksp_onchain_transport_lib::YellowstoneSubscribeFilterName::new("blocks-meta").expect("block-meta filter name must validate");
|
|
let entry_name = ksp_onchain_transport_lib::YellowstoneSubscribeFilterName::new("entry").expect("entry filter name must validate");
|
|
assert!(request.insert_account_filter(account_name, ksp_onchain_transport_lib::YellowstoneSubscribeAccountFilter::new()).is_ok());
|
|
assert!(request.insert_slot_filter(slot_name, ksp_onchain_transport_lib::YellowstoneSubscribeSlotFilter::new()).is_ok());
|
|
assert!(request.insert_transaction_filter(transaction_name, ksp_onchain_transport_lib::YellowstoneSubscribeTransactionFilter::new()).is_ok());
|
|
assert!(
|
|
request
|
|
.insert_transaction_status_filter(transaction_status_name, ksp_onchain_transport_lib::YellowstoneSubscribeTransactionFilter::new())
|
|
.is_ok()
|
|
);
|
|
assert!(request.insert_block_filter(block_name, ksp_onchain_transport_lib::YellowstoneSubscribeBlockFilter::new()).is_ok());
|
|
assert!(request.insert_blocks_meta_filter(block_meta_name, ksp_onchain_transport_lib::YellowstoneSubscribeBlocksMetaFilter::new()).is_ok());
|
|
assert!(request.insert_entry_filter(entry_name, ksp_onchain_transport_lib::YellowstoneSubscribeEntryFilter::new()).is_ok());
|
|
request.set_commitment(std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Confirmed));
|
|
let slice = ksp_onchain_transport_lib::YellowstoneAccountsDataSlice::new(4, 32).expect("account-data slice must validate");
|
|
assert!(request.push_accounts_data_slice(slice).is_ok());
|
|
request.set_ping(std::option::Option::Some(ksp_onchain_transport_lib::YellowstoneSubscribePing::new(7)));
|
|
request.set_from_slot(std::option::Option::Some(99));
|
|
assert!(request.validate().is_ok());
|
|
assert_eq!(request.account_filter_count(), 1);
|
|
assert_eq!(request.slot_filter_count(), 1);
|
|
assert_eq!(request.transaction_filter_count(), 1);
|
|
assert_eq!(request.transaction_status_filter_count(), 1);
|
|
assert_eq!(request.block_filter_count(), 1);
|
|
assert_eq!(request.blocks_meta_filter_count(), 1);
|
|
assert_eq!(request.entry_filter_count(), 1);
|
|
assert_eq!(request.commitment(), std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Confirmed));
|
|
assert_eq!(request.accounts_data_slices(), &[slice]);
|
|
assert_eq!(request.ping(), std::option::Option::Some(ksp_onchain_transport_lib::YellowstoneSubscribePing::new(7)));
|
|
assert_eq!(request.from_slot(), std::option::Option::Some(99));
|
|
}
|
|
|
|
#[test]
|
|
fn public_v0_2_9_pre_005_yellowstone_accounts_slots_contract_is_available_from_crate_root() {
|
|
let account = ksp_core_lib::Pubkey::new_from_array([1_u8; 32]);
|
|
let owner = ksp_core_lib::Pubkey::new_from_array([2_u8; 32]);
|
|
let mut accounts = ksp_onchain_transport_lib::YellowstoneSubscribeAccountFilter::new();
|
|
assert!(accounts.push_account(account).is_ok());
|
|
assert!(accounts.push_owner(owner).is_ok());
|
|
let memcmp = ksp_onchain_transport_lib::YellowstoneAccountMemcmp::bytes(0, vec![1_u8, 2, 3]).expect("public memcmp must validate");
|
|
assert!(accounts.push_filter(ksp_onchain_transport_lib::YellowstoneAccountFilterPredicate::Memcmp(memcmp)).is_ok());
|
|
accounts.set_nonempty_txn_signature(std::option::Option::Some(true));
|
|
let cuckoo =
|
|
ksp_onchain_transport_lib::YellowstoneCuckooFilter::new(vec![0_u8; 16], 4, 4, 8, 1, ksp_onchain_transport_lib::YellowstoneCuckooHashAlgorithm::SipHash)
|
|
.expect("public cuckoo filter must validate");
|
|
accounts.set_cuckoo_accounts_filter(std::option::Option::Some(cuckoo));
|
|
let mut slots = ksp_onchain_transport_lib::YellowstoneSubscribeSlotFilter::new();
|
|
slots.set_filter_by_commitment(std::option::Option::Some(true));
|
|
slots.set_interslot_updates(std::option::Option::Some(true));
|
|
let timestamp = ksp_onchain_transport_lib::YellowstoneUpdateTimestamp::new(1, 2).expect("public timestamp must validate");
|
|
let signature = ksp_onchain_transport_lib::YellowstoneTransactionSignature::new([3_u8; 64]);
|
|
assert_eq!(timestamp.nanos(), 2);
|
|
assert_eq!(signature.as_bytes(), &[3_u8; 64]);
|
|
assert_eq!(slots.filter_by_commitment(), std::option::Option::Some(true));
|
|
let _account_info = std::any::type_name::<ksp_onchain_transport_lib::YellowstoneAccountInfo>();
|
|
let _account_update = std::any::type_name::<ksp_onchain_transport_lib::YellowstoneAccountUpdate>();
|
|
let _slot_update = std::any::type_name::<ksp_onchain_transport_lib::YellowstoneSlotUpdate>();
|
|
let _slot_status = ksp_onchain_transport_lib::YellowstoneSlotStatus::FirstShredReceived;
|
|
let _lamports = ksp_onchain_transport_lib::YellowstoneAccountLamportsFilter::Gt(10);
|
|
let _encoding = ksp_onchain_transport_lib::YellowstoneAccountMemcmpEncoding::Bytes;
|
|
}
|
|
|
|
#[test]
|
|
fn public_v0_2_9_pre_007_yellowstone_transactions_contract_is_available_from_crate_root() {
|
|
let mut filter = ksp_onchain_transport_lib::YellowstoneSubscribeTransactionFilter::new();
|
|
filter.set_vote(std::option::Option::Some(false));
|
|
filter.set_failed(std::option::Option::Some(true));
|
|
let selector = ksp_onchain_transport_lib::YellowstoneTransactionSignatureSelector::new("1".repeat(64)).expect("signature selector must validate");
|
|
filter.set_signature(std::option::Option::Some(selector));
|
|
assert!(filter.push_account_include(ksp_core_lib::Pubkey::new_from_array([1_u8; 32])).is_ok());
|
|
assert!(filter.push_account_exclude(ksp_core_lib::Pubkey::new_from_array([2_u8; 32])).is_ok());
|
|
assert!(filter.push_account_required(ksp_core_lib::Pubkey::new_from_array([3_u8; 32])).is_ok());
|
|
filter.set_token_accounts(std::option::Option::Some(ksp_onchain_transport_lib::YellowstoneTokenAccountExpansion::All));
|
|
assert_eq!(filter.token_accounts(), std::option::Option::Some(ksp_onchain_transport_lib::YellowstoneTokenAccountExpansion::All));
|
|
let _hash = std::any::type_name::<ksp_onchain_transport_lib::YellowstoneHashBytes>();
|
|
let _instruction = std::any::type_name::<ksp_onchain_transport_lib::YellowstoneCompiledInstruction>();
|
|
let _lookup = std::any::type_name::<ksp_onchain_transport_lib::YellowstoneMessageAddressTableLookup>();
|
|
let _config = std::any::type_name::<ksp_onchain_transport_lib::YellowstoneTransactionConfig>();
|
|
let _message = std::any::type_name::<ksp_onchain_transport_lib::YellowstoneTransactionMessage>();
|
|
let _stored = std::any::type_name::<ksp_onchain_transport_lib::YellowstoneStoredTransaction>();
|
|
let _meta = std::any::type_name::<ksp_onchain_transport_lib::YellowstoneTransactionStatusMeta>();
|
|
let _info = std::any::type_name::<ksp_onchain_transport_lib::YellowstoneTransactionInfo>();
|
|
let _update = std::any::type_name::<ksp_onchain_transport_lib::YellowstoneTransactionUpdate>();
|
|
let _status = std::any::type_name::<ksp_onchain_transport_lib::YellowstoneTransactionStatusUpdate>();
|
|
let _error = std::any::type_name::<ksp_onchain_transport_lib::YellowstoneTransactionError>();
|
|
let _inner = std::any::type_name::<ksp_onchain_transport_lib::YellowstoneInnerInstructions>();
|
|
let _token = std::any::type_name::<ksp_onchain_transport_lib::YellowstoneTokenBalance>();
|
|
let _return_data = std::any::type_name::<ksp_onchain_transport_lib::YellowstoneReturnData>();
|
|
let _reward = std::any::type_name::<ksp_onchain_transport_lib::YellowstoneReward>();
|
|
}
|
|
|
|
#[test]
|
|
fn public_v0_2_9_pre_008_yellowstone_blocks_contract_is_available_from_crate_root() {
|
|
let account = ksp_core_lib::Pubkey::new_from_array([71_u8; 32]);
|
|
let mut block = ksp_onchain_transport_lib::YellowstoneSubscribeBlockFilter::new();
|
|
assert!(block.push_account_include(account).is_ok());
|
|
block.set_include_transactions(std::option::Option::Some(true));
|
|
block.set_include_accounts(std::option::Option::Some(false));
|
|
block.set_include_entries(std::option::Option::Some(true));
|
|
assert_eq!(block.account_include(), &[account]);
|
|
assert_eq!(block.include_transactions(), std::option::Option::Some(true));
|
|
assert_eq!(block.include_accounts(), std::option::Option::Some(false));
|
|
assert_eq!(block.include_entries(), std::option::Option::Some(true));
|
|
let mut request = ksp_onchain_transport_lib::YellowstoneSubscribeRequest::new();
|
|
assert!(
|
|
request
|
|
.insert_block_filter(ksp_onchain_transport_lib::YellowstoneSubscribeFilterName::new("blocks").expect("filter name must validate"), block,)
|
|
.is_ok()
|
|
);
|
|
assert!(
|
|
request
|
|
.insert_blocks_meta_filter(
|
|
ksp_onchain_transport_lib::YellowstoneSubscribeFilterName::new("block-meta").expect("filter name must validate"),
|
|
ksp_onchain_transport_lib::YellowstoneSubscribeBlocksMetaFilter::new(),
|
|
)
|
|
.is_ok()
|
|
);
|
|
assert!(
|
|
request
|
|
.insert_entry_filter(
|
|
ksp_onchain_transport_lib::YellowstoneSubscribeFilterName::new("entry").expect("filter name must validate"),
|
|
ksp_onchain_transport_lib::YellowstoneSubscribeEntryFilter::new(),
|
|
)
|
|
.is_ok()
|
|
);
|
|
assert_eq!(request.block_filter_count(), 1);
|
|
assert_eq!(request.blocks_meta_filter_count(), 1);
|
|
assert_eq!(request.entry_filter_count(), 1);
|
|
let _block_update = std::any::type_name::<ksp_onchain_transport_lib::YellowstoneBlockUpdate>();
|
|
let _block_meta = std::any::type_name::<ksp_onchain_transport_lib::YellowstoneBlockMetaUpdate>();
|
|
let _block_rewards = std::any::type_name::<ksp_onchain_transport_lib::YellowstoneBlockRewards>();
|
|
let _entry_info = std::any::type_name::<ksp_onchain_transport_lib::YellowstoneEntryInfo>();
|
|
let _entry_update = std::any::type_name::<ksp_onchain_transport_lib::YellowstoneEntryUpdate>();
|
|
}
|
|
|
|
#[test]
|
|
fn public_v0_2_9_pre_009_yellowstone_bidi_session_contract_is_available_from_crate_root() {
|
|
fn assert_send<T: Send>() {
|
|
let _ = std::marker::PhantomData::<T>;
|
|
return;
|
|
}
|
|
assert_send::<ksp_onchain_transport_lib::SolanaYellowstoneGrpcSubscribeSession>();
|
|
assert_send::<ksp_onchain_transport_lib::YellowstoneSubscribeUpdate>();
|
|
let _open = ksp_onchain_transport_lib::YellowstoneGrpcChannel::open_standard_subscribe;
|
|
let _session = std::any::type_name::<ksp_onchain_transport_lib::SolanaYellowstoneGrpcSubscribeSession>();
|
|
let _ping = std::any::type_name::<ksp_onchain_transport_lib::YellowstoneSubscribePingUpdate>();
|
|
let _pong = std::any::type_name::<ksp_onchain_transport_lib::YellowstoneSubscribePongUpdate>();
|
|
let _states = [
|
|
ksp_onchain_transport_lib::YellowstoneGrpcSubscribeState::Active,
|
|
ksp_onchain_transport_lib::YellowstoneGrpcSubscribeState::Closing,
|
|
ksp_onchain_transport_lib::YellowstoneGrpcSubscribeState::Closed,
|
|
ksp_onchain_transport_lib::YellowstoneGrpcSubscribeState::Failed,
|
|
];
|
|
assert_eq!(ksp_onchain_transport_lib::ERROR_CODE_GRPC_BACKPRESSURE_OVERFLOW.domain(), "onchain_transport");
|
|
assert_eq!(ksp_onchain_transport_lib::ERROR_CODE_GRPC_BACKPRESSURE_OVERFLOW.code(), "grpc_backpressure_overflow");
|
|
assert_eq!(ksp_onchain_transport_lib::ERROR_CODE_GRPC_SESSION_CLOSED.domain(), "onchain_transport");
|
|
assert_eq!(ksp_onchain_transport_lib::ERROR_CODE_GRPC_SESSION_CLOSED.code(), "grpc_session_closed");
|
|
}
|
|
|
|
#[test]
|
|
fn public_v0_2_9_pre_010_yellowstone_reconnect_snapshot_is_available_from_crate_root() {
|
|
fn assert_copy<T: Copy>() {
|
|
let _ = std::marker::PhantomData::<T>;
|
|
return;
|
|
}
|
|
assert_copy::<ksp_onchain_transport_lib::YellowstoneGrpcSubscribeSnapshot>();
|
|
let _snapshot = std::any::type_name::<ksp_onchain_transport_lib::YellowstoneGrpcSubscribeSnapshot>();
|
|
let _state = ksp_onchain_transport_lib::YellowstoneGrpcSubscribeState::Reconnecting;
|
|
let _session_snapshot = ksp_onchain_transport_lib::SolanaYellowstoneGrpcSubscribeSession::snapshot;
|
|
let _snapshot_source = ksp_onchain_transport_lib::SolanaYellowstoneGrpcSubscribeSession::snapshot_source;
|
|
let _source_type = std::any::type_name::<ksp_onchain_transport_lib::YellowstoneGrpcSubscribeSnapshotSource>();
|
|
let _source_current = ksp_onchain_transport_lib::YellowstoneGrpcSubscribeSnapshotSource::current;
|
|
let _source_wait = ksp_onchain_transport_lib::YellowstoneGrpcSubscribeSnapshotSource::wait_for_change;
|
|
let _reconnect_count = ksp_onchain_transport_lib::YellowstoneGrpcSubscribeSnapshot::reconnect_count;
|
|
let _gap_count = ksp_onchain_transport_lib::YellowstoneGrpcSubscribeSnapshot::continuity_gap_count;
|
|
let _duplicate_count = ksp_onchain_transport_lib::YellowstoneGrpcSubscribeSnapshot::duplicate_update_count;
|
|
let _replay_count = ksp_onchain_transport_lib::YellowstoneGrpcSubscribeSnapshot::replay_attempt_count;
|
|
let _delivery_count = ksp_onchain_transport_lib::YellowstoneGrpcSubscribeSnapshot::replay_delivery_count;
|
|
let _coverage_unproven_count = ksp_onchain_transport_lib::YellowstoneGrpcSubscribeSnapshot::replay_coverage_unproven_count;
|
|
let _requested = ksp_onchain_transport_lib::YellowstoneGrpcSubscribeSnapshot::last_requested_from_slot;
|
|
let _observed = ksp_onchain_transport_lib::YellowstoneGrpcSubscribeSnapshot::last_observed_slot;
|
|
let _terminal = ksp_onchain_transport_lib::YellowstoneGrpcSubscribeSnapshot::terminal_error_code;
|
|
}
|
|
|
|
#[test]
|
|
fn public_v0_3_10_pre_004_observed_get_block_surface_is_available_from_crate_root() {
|
|
let method = ksp_onchain_transport_lib::HttpTransportPool::get_block_observed;
|
|
let _ = method;
|
|
return;
|
|
}
|
|
|
|
#[test]
|
|
fn public_v0_3_13_pre_002_yellowstone_subscribe_identity_is_opaque_and_available_from_crate_root() {
|
|
let request = ksp_onchain_transport_lib::YellowstoneSubscribeRequest::new();
|
|
let identity = request.identity().expect("empty validated request identity must build");
|
|
let _identity_type = std::any::type_name::<ksp_onchain_transport_lib::YellowstoneSubscribeRequestIdentity>();
|
|
let debug = std::format!("{identity:?}");
|
|
assert!(debug.contains("YellowstoneSubscribeRequestIdentity"));
|
|
assert!(debug.contains("byte_len"));
|
|
assert!(!debug.contains("bytes:"));
|
|
return;
|
|
}
|
|
|
|
#[test]
|
|
fn public_v0_3_15_pre_002_websocket_endpoint_capability_contract_is_available_from_crate_root() {
|
|
let endpoint = ksp_onchain_transport_lib::WsEndpointSettings::new(
|
|
"typed_public",
|
|
true,
|
|
ksp_onchain_transport_lib::WsProviderName::new("public"),
|
|
ksp_onchain_transport_lib::WsClusterName::new("devnet"),
|
|
ksp_onchain_transport_lib::WsProtocolKind::SolanaStandard,
|
|
ksp_onchain_transport_lib::WsEndpointUrl::parse("wss://api.devnet.solana.com").expect("public WebSocket URL fixture must parse"),
|
|
ksp_onchain_transport_lib::WsSessionSettings::default(),
|
|
)
|
|
.with_subscription_capabilities(std::vec![ksp_onchain_transport_lib::WsSubscriptionKind::Logs, ksp_onchain_transport_lib::WsSubscriptionKind::Block,]);
|
|
assert!(endpoint.supports_subscription(ksp_onchain_transport_lib::WsSubscriptionKind::Logs));
|
|
assert!(endpoint.supports_subscription(ksp_onchain_transport_lib::WsSubscriptionKind::Block));
|
|
assert!(!endpoint.supports_subscription(ksp_onchain_transport_lib::WsSubscriptionKind::HeliusTransaction));
|
|
assert_eq!(endpoint.subscription_capabilities().map(|capabilities| return capabilities.len()), std::option::Option::Some(2));
|
|
}
|