778 lines
44 KiB
Rust
778 lines
44 KiB
Rust
// file: crates/ksp-onchain-transport-lib/unit_tests/grpc_subscribe.rs
|
|
// version: 5
|
|
|
|
fn filter_name(value: &str) -> crate::YellowstoneSubscribeFilterName {
|
|
return crate::YellowstoneSubscribeFilterName::new(value).expect("fixture filter name must validate");
|
|
}
|
|
|
|
fn minimal_transaction_info(signature_byte: u8, index: u64) -> yellowstone_grpc_proto::geyser::SubscribeUpdateTransactionInfo {
|
|
let meta = yellowstone_grpc_proto::solana::storage::confirmed_block::TransactionStatusMeta { fee: 5_000, ..std::default::Default::default() };
|
|
return yellowstone_grpc_proto::geyser::SubscribeUpdateTransactionInfo {
|
|
signature: vec![signature_byte; 64],
|
|
is_vote: false,
|
|
transaction: std::option::Option::Some(yellowstone_grpc_proto::solana::storage::confirmed_block::Transaction {
|
|
signatures: vec![vec![signature_byte; 64]],
|
|
message: std::option::Option::Some(yellowstone_grpc_proto::solana::storage::confirmed_block::Message {
|
|
header: std::option::Option::Some(yellowstone_grpc_proto::solana::storage::confirmed_block::MessageHeader {
|
|
num_required_signatures: 1,
|
|
num_readonly_signed_accounts: 0,
|
|
num_readonly_unsigned_accounts: 0,
|
|
}),
|
|
account_keys: vec![vec![1_u8; 32]],
|
|
recent_blockhash: vec![2_u8; 32],
|
|
instructions: vec![],
|
|
versioned: false,
|
|
address_table_lookups: vec![],
|
|
config: std::option::Option::None,
|
|
}),
|
|
}),
|
|
meta: std::option::Option::Some(meta),
|
|
index,
|
|
};
|
|
}
|
|
|
|
#[test]
|
|
fn yellowstone_subscribe_filter_name_is_bounded_globally_unique_and_debug_redacted() {
|
|
assert!(crate::YellowstoneSubscribeFilterName::new("").is_err());
|
|
assert!(crate::YellowstoneSubscribeFilterName::new(" leading").is_err());
|
|
assert!(crate::YellowstoneSubscribeFilterName::new("trailing ").is_err());
|
|
assert!(crate::YellowstoneSubscribeFilterName::new("line\nbreak").is_err());
|
|
assert!(crate::YellowstoneSubscribeFilterName::new("x".repeat(129)).is_err());
|
|
let name = filter_name("account-primary");
|
|
assert_eq!(name.as_str(), "account-primary");
|
|
assert!(!format!("{name:?}").contains("account-primary"));
|
|
let mut request = crate::YellowstoneSubscribeRequest::new();
|
|
assert!(request.insert_account_filter(name.clone(), crate::YellowstoneSubscribeAccountFilter::new()).is_ok());
|
|
let duplicate = request.insert_slot_filter(name, crate::YellowstoneSubscribeSlotFilter::new());
|
|
assert!(duplicate.is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn yellowstone_subscribe_empty_and_named_empty_maps_encode_exactly() {
|
|
let empty = crate::YellowstoneSubscribeRequest::new().to_wire().expect("empty request must encode");
|
|
assert!(empty.accounts.is_empty());
|
|
assert!(empty.slots.is_empty());
|
|
assert!(empty.transactions.is_empty());
|
|
assert!(empty.transactions_status.is_empty());
|
|
assert!(empty.blocks.is_empty());
|
|
assert!(empty.blocks_meta.is_empty());
|
|
assert!(empty.entry.is_empty());
|
|
assert_eq!(empty.commitment, std::option::Option::None);
|
|
assert!(empty.accounts_data_slice.is_empty());
|
|
assert_eq!(empty.ping, std::option::Option::None);
|
|
assert_eq!(empty.from_slot, std::option::Option::None);
|
|
let mut request = crate::YellowstoneSubscribeRequest::new();
|
|
assert!(request.insert_account_filter(filter_name("accounts"), crate::YellowstoneSubscribeAccountFilter::new()).is_ok());
|
|
assert!(request.insert_slot_filter(filter_name("slots"), crate::YellowstoneSubscribeSlotFilter::new()).is_ok());
|
|
assert!(request.insert_transaction_filter(filter_name("transactions"), crate::YellowstoneSubscribeTransactionFilter::new()).is_ok());
|
|
assert!(request.insert_transaction_status_filter(filter_name("transaction-status"), crate::YellowstoneSubscribeTransactionFilter::new()).is_ok());
|
|
assert!(request.insert_block_filter(filter_name("blocks"), crate::YellowstoneSubscribeBlockFilter::new()).is_ok());
|
|
assert!(request.insert_blocks_meta_filter(filter_name("blocks-meta"), crate::YellowstoneSubscribeBlocksMetaFilter::new()).is_ok());
|
|
assert!(request.insert_entry_filter(filter_name("entry"), crate::YellowstoneSubscribeEntryFilter::new()).is_ok());
|
|
let wire = request.to_wire().expect("named empty request must encode");
|
|
assert_eq!(wire.accounts.len(), 1);
|
|
assert_eq!(wire.slots.len(), 1);
|
|
assert_eq!(wire.transactions.len(), 1);
|
|
assert_eq!(wire.transactions_status.len(), 1);
|
|
assert_eq!(wire.blocks.len(), 1);
|
|
assert_eq!(wire.blocks_meta.len(), 1);
|
|
assert_eq!(wire.entry.len(), 1);
|
|
assert_eq!(wire.accounts.get("accounts"), std::option::Option::Some(&yellowstone_grpc_proto::geyser::SubscribeRequestFilterAccounts::default()));
|
|
assert_eq!(wire.slots.get("slots"), std::option::Option::Some(&yellowstone_grpc_proto::geyser::SubscribeRequestFilterSlots::default()));
|
|
assert_eq!(
|
|
wire.transactions.get("transactions"),
|
|
std::option::Option::Some(&yellowstone_grpc_proto::geyser::SubscribeRequestFilterTransactions::default()),
|
|
);
|
|
assert_eq!(
|
|
wire.transactions_status.get("transaction-status"),
|
|
std::option::Option::Some(&yellowstone_grpc_proto::geyser::SubscribeRequestFilterTransactions::default())
|
|
);
|
|
assert_eq!(wire.blocks.get("blocks"), std::option::Option::Some(&yellowstone_grpc_proto::geyser::SubscribeRequestFilterBlocks::default()));
|
|
assert!(wire.blocks_meta.contains_key("blocks-meta"));
|
|
assert!(wire.entry.contains_key("entry"));
|
|
}
|
|
|
|
#[test]
|
|
fn yellowstone_subscribe_common_fields_preserve_optional_and_ordered_wire_semantics() {
|
|
let mut request = crate::YellowstoneSubscribeRequest::new();
|
|
request.set_commitment(std::option::Option::Some(crate::SolanaCommitment::Finalized));
|
|
let first = crate::YellowstoneAccountsDataSlice::new(8, 16).expect("first slice must validate");
|
|
let second = crate::YellowstoneAccountsDataSlice::new(64, 0).expect("zero-length slice remains representable");
|
|
assert!(request.push_accounts_data_slice(first).is_ok());
|
|
assert!(request.push_accounts_data_slice(second).is_ok());
|
|
request.set_ping(std::option::Option::Some(crate::YellowstoneSubscribePing::new(-7)));
|
|
request.set_from_slot(std::option::Option::Some(42));
|
|
assert_eq!(request.commitment(), std::option::Option::Some(crate::SolanaCommitment::Finalized));
|
|
assert_eq!(request.accounts_data_slices(), &[first, second]);
|
|
assert_eq!(request.ping(), std::option::Option::Some(crate::YellowstoneSubscribePing::new(-7)));
|
|
assert_eq!(request.from_slot(), std::option::Option::Some(42));
|
|
let wire = request.to_wire().expect("common fields must encode");
|
|
assert_eq!(wire.commitment, std::option::Option::Some(yellowstone_grpc_proto::geyser::CommitmentLevel::Finalized as i32));
|
|
assert_eq!(wire.accounts_data_slice.len(), 2);
|
|
assert_eq!(wire.accounts_data_slice[0].offset, 8);
|
|
assert_eq!(wire.accounts_data_slice[0].length, 16);
|
|
assert_eq!(wire.accounts_data_slice[1].offset, 64);
|
|
assert_eq!(wire.accounts_data_slice[1].length, 0);
|
|
assert_eq!(wire.ping.map(|ping| return ping.id), std::option::Option::Some(-7));
|
|
assert_eq!(wire.from_slot, std::option::Option::Some(42));
|
|
}
|
|
|
|
#[test]
|
|
fn yellowstone_subscribe_common_bounds_reject_before_wire_conversion() {
|
|
assert!(crate::YellowstoneAccountsDataSlice::new(0, 64 * 1024 * 1024).is_ok());
|
|
assert!(crate::YellowstoneAccountsDataSlice::new(0, 64 * 1024 * 1024 + 1).is_err());
|
|
assert!(crate::YellowstoneAccountsDataSlice::new(u64::MAX, 1).is_err());
|
|
let mut slices = crate::YellowstoneSubscribeRequest::new();
|
|
for index in 0..128_u64 {
|
|
let slice = crate::YellowstoneAccountsDataSlice::new(index, 1).expect("bounded fixture slice must validate");
|
|
assert!(slices.push_accounts_data_slice(slice).is_ok());
|
|
}
|
|
let excess = crate::YellowstoneAccountsDataSlice::new(129, 1).expect("excess fixture slice itself must validate");
|
|
assert!(slices.push_accounts_data_slice(excess).is_err());
|
|
let mut filters = crate::YellowstoneSubscribeRequest::new();
|
|
for index in 0..1_024_u32 {
|
|
let name = crate::YellowstoneSubscribeFilterName::new(format!("f{index}")).expect("bounded filter name must validate");
|
|
assert!(filters.insert_account_filter(name, crate::YellowstoneSubscribeAccountFilter::new()).is_ok());
|
|
}
|
|
let excess_name = crate::YellowstoneSubscribeFilterName::new("excess").expect("excess filter name must validate independently");
|
|
assert!(filters.insert_account_filter(excess_name, crate::YellowstoneSubscribeAccountFilter::new()).is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn yellowstone_subscribe_debug_omits_filter_names_and_future_payloads() {
|
|
let mut request = crate::YellowstoneSubscribeRequest::new();
|
|
assert!(request.insert_account_filter(filter_name("sensitive-label"), crate::YellowstoneSubscribeAccountFilter::new()).is_ok());
|
|
request.set_ping(std::option::Option::Some(crate::YellowstoneSubscribePing::new(9)));
|
|
request.set_from_slot(std::option::Option::Some(77));
|
|
let debug = format!("{request:?}");
|
|
assert!(!debug.contains("sensitive-label"));
|
|
assert!(debug.contains("account_filter_count"));
|
|
assert!(debug.contains("from_slot"));
|
|
}
|
|
|
|
#[test]
|
|
fn yellowstone_account_and_slot_filters_encode_complete_current_wire() {
|
|
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 filter = crate::YellowstoneSubscribeAccountFilter::new();
|
|
assert!(filter.push_account(account).is_ok());
|
|
assert!(filter.push_owner(owner).is_ok());
|
|
let raw = crate::YellowstoneAccountMemcmp::bytes(4, vec![1_u8, 2, 3]).expect("raw memcmp must validate");
|
|
let base58 = crate::YellowstoneAccountMemcmp::base58(8, "1234").expect("base58 memcmp must validate");
|
|
let base64 = crate::YellowstoneAccountMemcmp::base64(12, "AQID==").expect("base64 memcmp must validate");
|
|
assert!(filter.push_filter(crate::YellowstoneAccountFilterPredicate::Memcmp(raw)).is_ok());
|
|
assert!(filter.push_filter(crate::YellowstoneAccountFilterPredicate::Memcmp(base58)).is_ok());
|
|
assert!(filter.push_filter(crate::YellowstoneAccountFilterPredicate::Memcmp(base64)).is_ok());
|
|
assert!(filter.push_filter(crate::YellowstoneAccountFilterPredicate::DataSize(165)).is_ok());
|
|
assert!(filter.push_filter(crate::YellowstoneAccountFilterPredicate::TokenAccountState(true)).is_ok());
|
|
assert!(filter.push_filter(crate::YellowstoneAccountFilterPredicate::Lamports(crate::YellowstoneAccountLamportsFilter::Eq(1))).is_ok());
|
|
assert!(filter.push_filter(crate::YellowstoneAccountFilterPredicate::Lamports(crate::YellowstoneAccountLamportsFilter::Ne(2))).is_ok());
|
|
assert!(filter.push_filter(crate::YellowstoneAccountFilterPredicate::Lamports(crate::YellowstoneAccountLamportsFilter::Lt(3))).is_ok());
|
|
assert!(filter.push_filter(crate::YellowstoneAccountFilterPredicate::Lamports(crate::YellowstoneAccountLamportsFilter::Gt(4))).is_ok());
|
|
filter.set_nonempty_txn_signature(std::option::Option::Some(true));
|
|
let cuckoo =
|
|
crate::YellowstoneCuckooFilter::new(vec![9_u8; 16], 4, 4, 8, 77, crate::YellowstoneCuckooHashAlgorithm::SipHash).expect("cuckoo fixture must validate");
|
|
filter.set_cuckoo_accounts_filter(std::option::Option::Some(cuckoo));
|
|
let wire = filter.to_wire();
|
|
assert_eq!(wire.account, vec![account.to_string()]);
|
|
assert_eq!(wire.owner, vec![owner.to_string()]);
|
|
assert_eq!(wire.filters.len(), 9);
|
|
match wire.filters[0].filter.as_ref().expect("raw memcmp oneof must be present") {
|
|
yellowstone_grpc_proto::geyser::subscribe_request_filter_accounts_filter::Filter::Memcmp(value) => assert_eq!(
|
|
value.data,
|
|
std::option::Option::Some(yellowstone_grpc_proto::geyser::subscribe_request_filter_accounts_filter_memcmp::Data::Bytes(vec![1_u8, 2, 3]))
|
|
),
|
|
_ => panic!("first predicate must stay memcmp"),
|
|
}
|
|
match wire.filters[5].filter.as_ref().expect("lamports oneof must be present") {
|
|
yellowstone_grpc_proto::geyser::subscribe_request_filter_accounts_filter::Filter::Lamports(value) => {
|
|
assert_eq!(value.cmp, std::option::Option::Some(yellowstone_grpc_proto::geyser::subscribe_request_filter_accounts_filter_lamports::Cmp::Eq(1)))
|
|
},
|
|
_ => panic!("sixth predicate must stay lamports"),
|
|
}
|
|
assert_eq!(wire.nonempty_txn_signature, std::option::Option::Some(true));
|
|
let cuckoo = wire.cuckoo_accounts_filter.expect("cuckoo filter must be present");
|
|
assert_eq!(cuckoo.data, vec![9_u8; 16]);
|
|
assert_eq!(cuckoo.bucket_count, 4);
|
|
assert_eq!(cuckoo.entries_per_bucket, 4);
|
|
assert_eq!(cuckoo.fingerprint_bits, 8);
|
|
assert_eq!(cuckoo.hash_seed, 77);
|
|
assert_eq!(cuckoo.hash_algorithm, yellowstone_grpc_proto::geyser::CuckooHashAlgorithm::SipHash as i32);
|
|
let mut slots = crate::YellowstoneSubscribeSlotFilter::new();
|
|
slots.set_filter_by_commitment(std::option::Option::Some(false));
|
|
slots.set_interslot_updates(std::option::Option::Some(true));
|
|
assert_eq!(slots.filter_by_commitment(), std::option::Option::Some(false));
|
|
assert_eq!(slots.interslot_updates(), std::option::Option::Some(true));
|
|
let slots_wire = slots.to_wire();
|
|
assert_eq!(slots_wire.filter_by_commitment, std::option::Option::Some(false));
|
|
assert_eq!(slots_wire.interslot_updates, std::option::Option::Some(true));
|
|
}
|
|
|
|
#[test]
|
|
fn yellowstone_account_filter_bounds_and_debug_are_provider_neutral() {
|
|
assert!(crate::YellowstoneCuckooFilter::new(vec![], 0, 4, 8, 0, crate::YellowstoneCuckooHashAlgorithm::SipHash).is_err());
|
|
assert!(crate::YellowstoneCuckooFilter::new(vec![], 1, 0, 8, 0, crate::YellowstoneCuckooHashAlgorithm::SipHash).is_err());
|
|
assert!(crate::YellowstoneCuckooFilter::new(vec![], 1, 4, 7, 0, crate::YellowstoneCuckooHashAlgorithm::SipHash).is_err());
|
|
assert!(crate::YellowstoneCuckooFilter::new(vec![], 1, 4, 12, 0, crate::YellowstoneCuckooHashAlgorithm::SipHash).is_ok());
|
|
assert!(crate::YellowstoneAccountMemcmp::base58(0, "contains whitespace").is_err());
|
|
assert!(crate::YellowstoneAccountMemcmp::base64(0, "line\nbreak").is_err());
|
|
let memcmp = crate::YellowstoneAccountMemcmp::bytes(5, vec![7_u8, 8, 9]).expect("memcmp must validate");
|
|
let debug = format!("{memcmp:?}");
|
|
assert!(debug.contains("payload_length"));
|
|
assert!(!debug.contains("7, 8, 9"));
|
|
let mut filter = crate::YellowstoneSubscribeAccountFilter::new();
|
|
assert!(filter.push_account(ksp_core_lib::Pubkey::new_from_array([3_u8; 32])).is_ok());
|
|
assert!(filter.push_filter(crate::YellowstoneAccountFilterPredicate::Memcmp(memcmp)).is_ok());
|
|
let filter_debug = format!("{filter:?}");
|
|
assert!(filter_debug.contains("account_count"));
|
|
assert!(!filter_debug.contains(&ksp_core_lib::Pubkey::new_from_array([3_u8; 32]).to_string()));
|
|
}
|
|
|
|
#[test]
|
|
fn yellowstone_account_update_decodes_complete_wire_and_redacts_payload_debug() {
|
|
let signature = vec![6_u8; 64];
|
|
let wire = yellowstone_grpc_proto::geyser::SubscribeUpdate {
|
|
filters: vec!["accounts-main".to_owned(), "accounts-owner".to_owned()],
|
|
update_oneof: std::option::Option::Some(yellowstone_grpc_proto::geyser::subscribe_update::UpdateOneof::Account(
|
|
yellowstone_grpc_proto::geyser::SubscribeUpdateAccount {
|
|
account: std::option::Option::Some(yellowstone_grpc_proto::geyser::SubscribeUpdateAccountInfo {
|
|
pubkey: vec![1_u8; 32],
|
|
lamports: 42,
|
|
owner: vec![2_u8; 32],
|
|
executable: true,
|
|
rent_epoch: 9,
|
|
data: vec![0xAA_u8, 0xBB, 0xCC],
|
|
write_version: 7,
|
|
txn_signature: std::option::Option::Some(signature),
|
|
}),
|
|
slot: 123,
|
|
is_startup: true,
|
|
},
|
|
)),
|
|
created_at: std::option::Option::Some(yellowstone_grpc_proto::prost_types::Timestamp { seconds: 1_700_000_000, nanos: 123_456_789 }),
|
|
};
|
|
let update = super::decode_account_update(wire).expect("account update fixture must decode");
|
|
assert_eq!(update.filters()[0].as_str(), "accounts-main");
|
|
assert_eq!(update.filters()[1].as_str(), "accounts-owner");
|
|
assert_eq!(update.created_at().expect("timestamp must be present").seconds(), 1_700_000_000);
|
|
assert_eq!(update.created_at().expect("timestamp must be present").nanos(), 123_456_789);
|
|
assert_eq!(update.slot(), 123);
|
|
assert!(update.is_startup());
|
|
assert_eq!(update.account().pubkey(), &ksp_core_lib::Pubkey::new_from_array([1_u8; 32]));
|
|
assert_eq!(update.account().owner(), &ksp_core_lib::Pubkey::new_from_array([2_u8; 32]));
|
|
assert_eq!(update.account().lamports(), 42);
|
|
assert!(update.account().executable());
|
|
assert_eq!(update.account().rent_epoch(), 9);
|
|
assert_eq!(update.account().data(), &[0xAA_u8, 0xBB, 0xCC]);
|
|
assert_eq!(update.account().write_version(), 7);
|
|
assert_eq!(update.account().transaction_signature().expect("signature must be present").as_bytes(), &[6_u8; 64]);
|
|
let debug = format!("{update:?}");
|
|
assert!(!debug.contains("accounts-main"));
|
|
assert!(!debug.contains("170, 187, 204"));
|
|
assert!(!debug.contains(&ksp_core_lib::Pubkey::new_from_array([1_u8; 32]).to_string()));
|
|
}
|
|
|
|
#[test]
|
|
fn yellowstone_account_update_rejects_malformed_fixed_width_and_envelope_fields() {
|
|
let malformed_pubkey = yellowstone_grpc_proto::geyser::SubscribeUpdate {
|
|
filters: vec!["accounts".to_owned()],
|
|
update_oneof: std::option::Option::Some(yellowstone_grpc_proto::geyser::subscribe_update::UpdateOneof::Account(
|
|
yellowstone_grpc_proto::geyser::SubscribeUpdateAccount {
|
|
account: std::option::Option::Some(yellowstone_grpc_proto::geyser::SubscribeUpdateAccountInfo {
|
|
pubkey: vec![1_u8; 31],
|
|
lamports: 0,
|
|
owner: vec![2_u8; 32],
|
|
executable: false,
|
|
rent_epoch: 0,
|
|
data: vec![],
|
|
write_version: 0,
|
|
txn_signature: std::option::Option::None,
|
|
}),
|
|
slot: 0,
|
|
is_startup: false,
|
|
},
|
|
)),
|
|
created_at: std::option::Option::None,
|
|
};
|
|
assert!(super::decode_account_update(malformed_pubkey).is_err());
|
|
let malformed_signature = yellowstone_grpc_proto::geyser::SubscribeUpdate {
|
|
filters: vec!["accounts".to_owned()],
|
|
update_oneof: std::option::Option::Some(yellowstone_grpc_proto::geyser::subscribe_update::UpdateOneof::Account(
|
|
yellowstone_grpc_proto::geyser::SubscribeUpdateAccount {
|
|
account: std::option::Option::Some(yellowstone_grpc_proto::geyser::SubscribeUpdateAccountInfo {
|
|
pubkey: vec![1_u8; 32],
|
|
lamports: 0,
|
|
owner: vec![2_u8; 32],
|
|
executable: false,
|
|
rent_epoch: 0,
|
|
data: vec![],
|
|
write_version: 0,
|
|
txn_signature: std::option::Option::Some(vec![9_u8; 63]),
|
|
}),
|
|
slot: 0,
|
|
is_startup: false,
|
|
},
|
|
)),
|
|
created_at: std::option::Option::None,
|
|
};
|
|
assert!(super::decode_account_update(malformed_signature).is_err());
|
|
let missing_info = yellowstone_grpc_proto::geyser::SubscribeUpdate {
|
|
filters: vec!["accounts".to_owned()],
|
|
update_oneof: std::option::Option::Some(yellowstone_grpc_proto::geyser::subscribe_update::UpdateOneof::Account(
|
|
yellowstone_grpc_proto::geyser::SubscribeUpdateAccount { account: std::option::Option::None, slot: 0, is_startup: false },
|
|
)),
|
|
created_at: std::option::Option::None,
|
|
};
|
|
assert!(super::decode_account_update(missing_info).is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn yellowstone_slot_update_preserves_all_current_statuses_and_bounds_dead_error() {
|
|
let statuses = [
|
|
(yellowstone_grpc_proto::geyser::SlotStatus::SlotProcessed, crate::YellowstoneSlotStatus::Processed),
|
|
(yellowstone_grpc_proto::geyser::SlotStatus::SlotConfirmed, crate::YellowstoneSlotStatus::Confirmed),
|
|
(yellowstone_grpc_proto::geyser::SlotStatus::SlotFinalized, crate::YellowstoneSlotStatus::Finalized),
|
|
(yellowstone_grpc_proto::geyser::SlotStatus::SlotFirstShredReceived, crate::YellowstoneSlotStatus::FirstShredReceived),
|
|
(yellowstone_grpc_proto::geyser::SlotStatus::SlotCompleted, crate::YellowstoneSlotStatus::Completed),
|
|
(yellowstone_grpc_proto::geyser::SlotStatus::SlotCreatedBank, crate::YellowstoneSlotStatus::CreatedBank),
|
|
(yellowstone_grpc_proto::geyser::SlotStatus::SlotDead, crate::YellowstoneSlotStatus::Dead),
|
|
];
|
|
for (wire_status, expected) in statuses {
|
|
let wire = yellowstone_grpc_proto::geyser::SubscribeUpdate {
|
|
filters: vec!["slots".to_owned()],
|
|
update_oneof: std::option::Option::Some(yellowstone_grpc_proto::geyser::subscribe_update::UpdateOneof::Slot(
|
|
yellowstone_grpc_proto::geyser::SubscribeUpdateSlot {
|
|
slot: 88,
|
|
parent: std::option::Option::Some(87),
|
|
status: wire_status as i32,
|
|
dead_error: if expected == crate::YellowstoneSlotStatus::Dead {
|
|
std::option::Option::Some("fork rejected".to_owned())
|
|
} else {
|
|
std::option::Option::None
|
|
},
|
|
},
|
|
)),
|
|
created_at: std::option::Option::Some(yellowstone_grpc_proto::prost_types::Timestamp { seconds: 5, nanos: 6 }),
|
|
};
|
|
let update = super::decode_slot_update(wire).expect("slot update fixture must decode");
|
|
assert_eq!(update.status(), expected);
|
|
assert_eq!(update.slot(), 88);
|
|
assert_eq!(update.parent(), std::option::Option::Some(87));
|
|
assert_eq!(update.filters()[0].as_str(), "slots");
|
|
if expected == crate::YellowstoneSlotStatus::Dead {
|
|
assert_eq!(update.dead_error(), std::option::Option::Some("fork rejected"));
|
|
assert!(!format!("{update:?}").contains("fork rejected"));
|
|
}
|
|
}
|
|
let unknown = yellowstone_grpc_proto::geyser::SubscribeUpdate {
|
|
filters: vec!["slots".to_owned()],
|
|
update_oneof: std::option::Option::Some(yellowstone_grpc_proto::geyser::subscribe_update::UpdateOneof::Slot(
|
|
yellowstone_grpc_proto::geyser::SubscribeUpdateSlot {
|
|
slot: 1,
|
|
parent: std::option::Option::None,
|
|
status: 99,
|
|
dead_error: std::option::Option::None,
|
|
},
|
|
)),
|
|
created_at: std::option::Option::None,
|
|
};
|
|
assert!(super::decode_slot_update(unknown).is_err());
|
|
let oversized = yellowstone_grpc_proto::geyser::SubscribeUpdate {
|
|
filters: vec!["slots".to_owned()],
|
|
update_oneof: std::option::Option::Some(yellowstone_grpc_proto::geyser::subscribe_update::UpdateOneof::Slot(
|
|
yellowstone_grpc_proto::geyser::SubscribeUpdateSlot {
|
|
slot: 1,
|
|
parent: std::option::Option::None,
|
|
status: yellowstone_grpc_proto::geyser::SlotStatus::SlotDead as i32,
|
|
dead_error: std::option::Option::Some("x".repeat(16 * 1024 + 1)),
|
|
},
|
|
)),
|
|
created_at: std::option::Option::None,
|
|
};
|
|
assert!(super::decode_slot_update(oversized).is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn yellowstone_transaction_filters_encode_complete_current_wire_and_redact_selectors() {
|
|
let mut filter = crate::YellowstoneSubscribeTransactionFilter::new();
|
|
filter.set_vote(std::option::Option::Some(false));
|
|
filter.set_failed(std::option::Option::Some(true));
|
|
let signature = crate::YellowstoneTransactionSignatureSelector::new("1".repeat(64)).expect("signature selector must validate");
|
|
filter.set_signature(std::option::Option::Some(signature));
|
|
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());
|
|
let cuckoo =
|
|
crate::YellowstoneCuckooFilter::new(vec![0_u8; 16], 4, 4, 8, 7, crate::YellowstoneCuckooHashAlgorithm::SipHash).expect("cuckoo filter must validate");
|
|
filter.set_cuckoo_account_include(std::option::Option::Some(cuckoo));
|
|
filter.set_token_accounts(std::option::Option::Some(crate::YellowstoneTokenAccountExpansion::BalanceChanged));
|
|
let wire = filter.to_wire();
|
|
assert_eq!(wire.vote, std::option::Option::Some(false));
|
|
assert_eq!(wire.failed, std::option::Option::Some(true));
|
|
assert!(wire.signature.is_some());
|
|
assert_eq!(wire.account_include.len(), 1);
|
|
assert_eq!(wire.account_exclude.len(), 1);
|
|
assert_eq!(wire.account_required.len(), 1);
|
|
assert!(wire.cuckoo_account_include.is_some());
|
|
assert_eq!(wire.token_accounts, std::option::Option::Some(yellowstone_grpc_proto::geyser::TokenAccountExpansionControlFlag::BalanceChanged as i32));
|
|
let debug = format!("{filter:?}");
|
|
assert!(debug.contains("account_include_count"));
|
|
assert!(!debug.contains(&"1".repeat(32)));
|
|
assert!(!debug.contains(&ksp_core_lib::Pubkey::new_from_array([1_u8; 32]).to_string()));
|
|
assert!(crate::YellowstoneTransactionSignatureSelector::new("contains-0-O-I-l").is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn yellowstone_transaction_update_decodes_current_storage_wire_including_v1_config_and_meta() {
|
|
let confirmed = yellowstone_grpc_proto::geyser::SubscribeUpdateTransactionInfo {
|
|
signature: vec![9_u8; 64],
|
|
is_vote: false,
|
|
transaction: std::option::Option::Some(yellowstone_grpc_proto::solana::storage::confirmed_block::Transaction {
|
|
signatures: vec![vec![9_u8; 64], vec![8_u8; 64]],
|
|
message: std::option::Option::Some(yellowstone_grpc_proto::solana::storage::confirmed_block::Message {
|
|
header: std::option::Option::Some(yellowstone_grpc_proto::solana::storage::confirmed_block::MessageHeader {
|
|
num_required_signatures: 2,
|
|
num_readonly_signed_accounts: 1,
|
|
num_readonly_unsigned_accounts: 1,
|
|
}),
|
|
account_keys: vec![vec![1_u8; 32], vec![2_u8; 32]],
|
|
recent_blockhash: vec![3_u8; 32],
|
|
instructions: vec![yellowstone_grpc_proto::solana::storage::confirmed_block::CompiledInstruction {
|
|
program_id_index: 1,
|
|
accounts: vec![0_u8, 1],
|
|
data: vec![4_u8, 5, 6],
|
|
}],
|
|
versioned: true,
|
|
address_table_lookups: vec![yellowstone_grpc_proto::solana::storage::confirmed_block::MessageAddressTableLookup {
|
|
account_key: vec![4_u8; 32],
|
|
writable_indexes: vec![1_u8, 2],
|
|
readonly_indexes: vec![3_u8],
|
|
}],
|
|
config: std::option::Option::Some(yellowstone_grpc_proto::solana::storage::confirmed_block::TransactionConfig {
|
|
priority_fee: std::option::Option::Some(7),
|
|
compute_unit_limit: std::option::Option::Some(8),
|
|
loaded_accounts_data_size_limit: std::option::Option::Some(9),
|
|
heap_size: std::option::Option::Some(10),
|
|
}),
|
|
}),
|
|
}),
|
|
meta: std::option::Option::Some(yellowstone_grpc_proto::solana::storage::confirmed_block::TransactionStatusMeta {
|
|
err: std::option::Option::Some(yellowstone_grpc_proto::solana::storage::confirmed_block::TransactionError { err: vec![11_u8, 12] }),
|
|
fee: 5_000,
|
|
pre_balances: vec![100, 200],
|
|
post_balances: vec![90, 210],
|
|
inner_instructions: vec![yellowstone_grpc_proto::solana::storage::confirmed_block::InnerInstructions {
|
|
index: 0,
|
|
instructions: vec![yellowstone_grpc_proto::solana::storage::confirmed_block::InnerInstruction {
|
|
program_id_index: 1,
|
|
accounts: vec![0_u8],
|
|
data: vec![13_u8, 14],
|
|
stack_height: std::option::Option::Some(2),
|
|
}],
|
|
}],
|
|
inner_instructions_none: false,
|
|
log_messages: vec!["Program log: fixture".to_owned()],
|
|
log_messages_none: false,
|
|
pre_token_balances: vec![yellowstone_grpc_proto::solana::storage::confirmed_block::TokenBalance {
|
|
account_index: 0,
|
|
mint: "mint-fixture".to_owned(),
|
|
ui_token_amount: std::option::Option::Some(yellowstone_grpc_proto::solana::storage::confirmed_block::UiTokenAmount {
|
|
ui_amount: 1.5,
|
|
decimals: 6,
|
|
amount: "1500000".to_owned(),
|
|
ui_amount_string: "1.5".to_owned(),
|
|
}),
|
|
owner: "owner-fixture".to_owned(),
|
|
program_id: "program-fixture".to_owned(),
|
|
}],
|
|
post_token_balances: vec![],
|
|
rewards: vec![yellowstone_grpc_proto::solana::storage::confirmed_block::Reward {
|
|
pubkey: ksp_core_lib::Pubkey::new_from_array([5_u8; 32]).to_string(),
|
|
lamports: 17,
|
|
post_balance: 18,
|
|
reward_type: yellowstone_grpc_proto::solana::storage::confirmed_block::RewardType::Staking as i32,
|
|
commission: "5".to_owned(),
|
|
commission_bps: "500".to_owned(),
|
|
}],
|
|
loaded_writable_addresses: vec![vec![6_u8; 32]],
|
|
loaded_readonly_addresses: vec![vec![7_u8; 32]],
|
|
return_data: std::option::Option::Some(yellowstone_grpc_proto::solana::storage::confirmed_block::ReturnData {
|
|
program_id: vec![8_u8; 32],
|
|
data: vec![15_u8, 16],
|
|
}),
|
|
return_data_none: false,
|
|
compute_units_consumed: std::option::Option::Some(123),
|
|
cost_units: std::option::Option::Some(456),
|
|
}),
|
|
index: 3,
|
|
};
|
|
let wire = yellowstone_grpc_proto::geyser::SubscribeUpdate {
|
|
filters: vec!["transactions-main".to_owned()],
|
|
update_oneof: std::option::Option::Some(yellowstone_grpc_proto::geyser::subscribe_update::UpdateOneof::Transaction(
|
|
yellowstone_grpc_proto::geyser::SubscribeUpdateTransaction { transaction: std::option::Option::Some(confirmed), slot: 42 },
|
|
)),
|
|
created_at: std::option::Option::Some(yellowstone_grpc_proto::prost_types::Timestamp { seconds: 100, nanos: 200 }),
|
|
};
|
|
let update = super::decode_transaction_update(wire).expect("transaction update fixture must decode");
|
|
assert_eq!(update.slot(), 42);
|
|
assert_eq!(update.filters()[0].as_str(), "transactions-main");
|
|
assert_eq!(update.transaction().signature().as_bytes(), &[9_u8; 64]);
|
|
assert_eq!(format!("{:?}", update.transaction().signature()), "YellowstoneTransactionSignature(<redacted>)");
|
|
assert_eq!(update.transaction().index(), 3);
|
|
assert_eq!(update.transaction().transaction().signatures().len(), 2);
|
|
assert!(update.transaction().transaction().message().versioned());
|
|
let config = update.transaction().transaction().message().config().expect("v1 config must be preserved");
|
|
assert_eq!(config.priority_fee(), std::option::Option::Some(7));
|
|
assert_eq!(config.heap_size(), std::option::Option::Some(10));
|
|
assert_eq!(update.transaction().meta().fee(), 5_000);
|
|
assert_eq!(update.transaction().meta().error().expect("error must be present").as_bytes(), &[11_u8, 12]);
|
|
assert_eq!(update.transaction().meta().inner_instructions()[0].instructions()[0].stack_height(), std::option::Option::Some(2));
|
|
assert_eq!(update.transaction().meta().pre_token_balances()[0].ui_token_amount().expect("token amount must be present").amount(), "1500000");
|
|
let token_debug = format!("{:?}", update.transaction().meta().pre_token_balances()[0]);
|
|
assert!(!token_debug.contains("mint-fixture"));
|
|
assert!(!token_debug.contains("owner-fixture"));
|
|
assert!(!token_debug.contains("program-fixture"));
|
|
assert_eq!(update.transaction().meta().rewards()[0].reward_type(), crate::YellowstoneRewardType::Staking);
|
|
assert_eq!(update.transaction().meta().loaded_writable_addresses()[0], ksp_core_lib::Pubkey::new_from_array([6_u8; 32]));
|
|
assert_eq!(update.transaction().meta().return_data().expect("return data must be present").data(), &[15_u8, 16]);
|
|
assert_eq!(update.transaction().meta().compute_units_consumed(), std::option::Option::Some(123));
|
|
assert_eq!(update.transaction().meta().cost_units(), std::option::Option::Some(456));
|
|
let debug = format!("{update:?}");
|
|
assert!(!debug.contains("Program log: fixture"));
|
|
assert!(!debug.contains("11, 12"));
|
|
}
|
|
|
|
#[test]
|
|
fn yellowstone_transaction_status_update_preserves_error_and_rejects_malformed_signature() {
|
|
let wire = yellowstone_grpc_proto::geyser::SubscribeUpdate {
|
|
filters: vec!["status".to_owned()],
|
|
update_oneof: std::option::Option::Some(yellowstone_grpc_proto::geyser::subscribe_update::UpdateOneof::TransactionStatus(
|
|
yellowstone_grpc_proto::geyser::SubscribeUpdateTransactionStatus {
|
|
slot: 55,
|
|
signature: vec![2_u8; 64],
|
|
is_vote: true,
|
|
index: 4,
|
|
err: std::option::Option::Some(yellowstone_grpc_proto::solana::storage::confirmed_block::TransactionError { err: vec![99_u8] }),
|
|
},
|
|
)),
|
|
created_at: std::option::Option::None,
|
|
};
|
|
let update = super::decode_transaction_status_update(wire).expect("transaction-status update must decode");
|
|
assert_eq!(update.slot(), 55);
|
|
assert!(update.is_vote());
|
|
assert_eq!(update.index(), 4);
|
|
assert_eq!(update.signature().as_bytes(), &[2_u8; 64]);
|
|
assert_eq!(update.error().expect("status error must be present").as_bytes(), &[99_u8]);
|
|
assert!(!format!("{update:?}").contains("99"));
|
|
let malformed = yellowstone_grpc_proto::geyser::SubscribeUpdate {
|
|
filters: vec!["status".to_owned()],
|
|
update_oneof: std::option::Option::Some(yellowstone_grpc_proto::geyser::subscribe_update::UpdateOneof::TransactionStatus(
|
|
yellowstone_grpc_proto::geyser::SubscribeUpdateTransactionStatus {
|
|
slot: 1,
|
|
signature: vec![0_u8; 63],
|
|
is_vote: false,
|
|
index: 0,
|
|
err: std::option::Option::None,
|
|
},
|
|
)),
|
|
created_at: std::option::Option::None,
|
|
};
|
|
assert!(super::decode_transaction_status_update(malformed).is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn yellowstone_block_filter_encodes_complete_current_wire_and_redacts_selectors() {
|
|
let mut filter = crate::YellowstoneSubscribeBlockFilter::new();
|
|
let account = ksp_core_lib::Pubkey::new_from_array([31_u8; 32]);
|
|
assert!(filter.push_account_include(account).is_ok());
|
|
filter.set_include_transactions(std::option::Option::Some(true));
|
|
filter.set_include_accounts(std::option::Option::Some(false));
|
|
filter.set_include_entries(std::option::Option::Some(true));
|
|
let cuckoo = crate::YellowstoneCuckooFilter::new(vec![0_u8; 16], 4, 4, 8, 9, crate::YellowstoneCuckooHashAlgorithm::SipHash)
|
|
.expect("block Cuckoo filter must validate");
|
|
filter.set_cuckoo_account_include(std::option::Option::Some(cuckoo));
|
|
let wire = filter.to_wire();
|
|
assert_eq!(wire.account_include, vec![account.to_string()]);
|
|
assert_eq!(wire.include_transactions, std::option::Option::Some(true));
|
|
assert_eq!(wire.include_accounts, std::option::Option::Some(false));
|
|
assert_eq!(wire.include_entries, std::option::Option::Some(true));
|
|
assert!(wire.cuckoo_account_include.is_some());
|
|
let debug = format!("{filter:?}");
|
|
assert!(debug.contains("account_include_count"));
|
|
assert!(!debug.contains(&account.to_string()));
|
|
}
|
|
|
|
#[test]
|
|
fn yellowstone_block_update_reuses_transaction_account_entry_dtos_and_preserves_server_counts() {
|
|
let blockhash = ksp_core_lib::Pubkey::new_from_array([21_u8; 32]).to_string();
|
|
let parent_blockhash = ksp_core_lib::Pubkey::new_from_array([22_u8; 32]).to_string();
|
|
let reward_pubkey = ksp_core_lib::Pubkey::new_from_array([23_u8; 32]);
|
|
let account_pubkey = ksp_core_lib::Pubkey::new_from_array([24_u8; 32]);
|
|
let wire = yellowstone_grpc_proto::geyser::SubscribeUpdate {
|
|
filters: vec!["blocks-main".to_owned()],
|
|
update_oneof: std::option::Option::Some(yellowstone_grpc_proto::geyser::subscribe_update::UpdateOneof::Block(
|
|
yellowstone_grpc_proto::geyser::SubscribeUpdateBlock {
|
|
slot: 500,
|
|
blockhash: blockhash.clone(),
|
|
rewards: std::option::Option::Some(yellowstone_grpc_proto::solana::storage::confirmed_block::Rewards {
|
|
rewards: vec![yellowstone_grpc_proto::solana::storage::confirmed_block::Reward {
|
|
pubkey: reward_pubkey.to_string(),
|
|
lamports: 10,
|
|
post_balance: 11,
|
|
reward_type: yellowstone_grpc_proto::solana::storage::confirmed_block::RewardType::Fee as i32,
|
|
commission: "".to_owned(),
|
|
commission_bps: "".to_owned(),
|
|
}],
|
|
num_partitions: std::option::Option::Some(yellowstone_grpc_proto::solana::storage::confirmed_block::NumPartitions { num_partitions: 3 }),
|
|
}),
|
|
block_time: std::option::Option::Some(yellowstone_grpc_proto::solana::storage::confirmed_block::UnixTimestamp { timestamp: 1_700_000_000 }),
|
|
block_height: std::option::Option::Some(yellowstone_grpc_proto::solana::storage::confirmed_block::BlockHeight { block_height: 499 }),
|
|
transactions: vec![minimal_transaction_info(7, 2)],
|
|
parent_slot: 499,
|
|
parent_blockhash: parent_blockhash.clone(),
|
|
executed_transaction_count: 12,
|
|
updated_account_count: 34,
|
|
accounts: vec![yellowstone_grpc_proto::geyser::SubscribeUpdateAccountInfo {
|
|
pubkey: vec![24_u8; 32],
|
|
lamports: 77,
|
|
owner: vec![25_u8; 32],
|
|
executable: false,
|
|
rent_epoch: 4,
|
|
data: vec![1_u8, 2, 3],
|
|
write_version: 8,
|
|
txn_signature: std::option::Option::Some(vec![7_u8; 64]),
|
|
}],
|
|
entries_count: 56,
|
|
entries: vec![yellowstone_grpc_proto::geyser::SubscribeUpdateEntry {
|
|
slot: 500,
|
|
index: 4,
|
|
num_hashes: 5,
|
|
hash: vec![26_u8; 32],
|
|
executed_transaction_count: 6,
|
|
starting_transaction_index: 7,
|
|
}],
|
|
},
|
|
)),
|
|
created_at: std::option::Option::Some(yellowstone_grpc_proto::prost_types::Timestamp { seconds: 12, nanos: 34 }),
|
|
};
|
|
let update = super::decode_block_update(wire).expect("block update fixture must decode");
|
|
assert_eq!(update.filters()[0].as_str(), "blocks-main");
|
|
assert_eq!(update.slot(), 500);
|
|
assert_eq!(update.blockhash(), blockhash);
|
|
assert_eq!(update.parent_slot(), 499);
|
|
assert_eq!(update.parent_blockhash(), parent_blockhash);
|
|
assert_eq!(update.block_time(), std::option::Option::Some(1_700_000_000));
|
|
assert_eq!(update.block_height(), std::option::Option::Some(499));
|
|
assert_eq!(update.executed_transaction_count(), 12);
|
|
assert_eq!(update.transactions().len(), 1);
|
|
assert_eq!(update.transactions()[0].index(), 2);
|
|
assert_eq!(update.updated_account_count(), 34);
|
|
assert_eq!(update.accounts().len(), 1);
|
|
assert_eq!(update.accounts()[0].pubkey(), &account_pubkey);
|
|
assert_eq!(update.entries_count(), 56);
|
|
assert_eq!(update.entries().len(), 1);
|
|
assert_eq!(update.entries()[0].starting_transaction_index(), 7);
|
|
let rewards = update.rewards().expect("block rewards must be present");
|
|
assert_eq!(rewards.rewards().len(), 1);
|
|
assert_eq!(rewards.num_partitions(), std::option::Option::Some(3));
|
|
assert_eq!(rewards.rewards()[0].pubkey(), &reward_pubkey);
|
|
let debug = format!("{update:?}");
|
|
assert!(!debug.contains(&blockhash));
|
|
assert!(!debug.contains(&parent_blockhash));
|
|
assert!(!debug.contains(&reward_pubkey.to_string()));
|
|
assert!(!debug.contains(&account_pubkey.to_string()));
|
|
let malformed = yellowstone_grpc_proto::geyser::SubscribeUpdate {
|
|
filters: vec!["blocks-main".to_owned()],
|
|
update_oneof: std::option::Option::Some(yellowstone_grpc_proto::geyser::subscribe_update::UpdateOneof::Block(
|
|
yellowstone_grpc_proto::geyser::SubscribeUpdateBlock {
|
|
slot: 1,
|
|
blockhash: "not-a-solana-hash".to_owned(),
|
|
rewards: std::option::Option::None,
|
|
block_time: std::option::Option::None,
|
|
block_height: std::option::Option::None,
|
|
transactions: vec![],
|
|
parent_slot: 0,
|
|
parent_blockhash: ksp_core_lib::Pubkey::new_from_array([1_u8; 32]).to_string(),
|
|
executed_transaction_count: 0,
|
|
updated_account_count: 0,
|
|
accounts: vec![],
|
|
entries_count: 0,
|
|
entries: vec![],
|
|
},
|
|
)),
|
|
created_at: std::option::Option::None,
|
|
};
|
|
assert!(super::decode_block_update(malformed).is_err());
|
|
}
|
|
|
|
#[test]
|
|
fn yellowstone_block_meta_and_entry_updates_preserve_optional_and_legacy_entry_fields() {
|
|
let blockhash = ksp_core_lib::Pubkey::new_from_array([41_u8; 32]).to_string();
|
|
let parent_blockhash = ksp_core_lib::Pubkey::new_from_array([42_u8; 32]).to_string();
|
|
let meta_wire = yellowstone_grpc_proto::geyser::SubscribeUpdate {
|
|
filters: vec!["meta".to_owned()],
|
|
update_oneof: std::option::Option::Some(yellowstone_grpc_proto::geyser::subscribe_update::UpdateOneof::BlockMeta(
|
|
yellowstone_grpc_proto::geyser::SubscribeUpdateBlockMeta {
|
|
slot: 900,
|
|
blockhash: blockhash.clone(),
|
|
rewards: std::option::Option::None,
|
|
block_time: std::option::Option::None,
|
|
block_height: std::option::Option::None,
|
|
parent_slot: 899,
|
|
parent_blockhash: parent_blockhash.clone(),
|
|
executed_transaction_count: 17,
|
|
entries_count: 18,
|
|
},
|
|
)),
|
|
created_at: std::option::Option::None,
|
|
};
|
|
let meta = super::decode_block_meta_update(meta_wire).expect("block-meta update must decode");
|
|
assert_eq!(meta.slot(), 900);
|
|
assert_eq!(meta.blockhash(), blockhash);
|
|
assert_eq!(meta.parent_blockhash(), parent_blockhash);
|
|
assert_eq!(meta.rewards(), std::option::Option::None);
|
|
assert_eq!(meta.block_time(), std::option::Option::None);
|
|
assert_eq!(meta.block_height(), std::option::Option::None);
|
|
assert_eq!(meta.executed_transaction_count(), 17);
|
|
assert_eq!(meta.entries_count(), 18);
|
|
assert!(!format!("{meta:?}").contains(&blockhash));
|
|
let entry_wire = yellowstone_grpc_proto::geyser::SubscribeUpdate {
|
|
filters: vec!["entries".to_owned()],
|
|
update_oneof: std::option::Option::Some(yellowstone_grpc_proto::geyser::subscribe_update::UpdateOneof::Entry(
|
|
yellowstone_grpc_proto::geyser::SubscribeUpdateEntry {
|
|
slot: 900,
|
|
index: 3,
|
|
num_hashes: 4,
|
|
hash: vec![43_u8; 32],
|
|
executed_transaction_count: 5,
|
|
starting_transaction_index: 0,
|
|
},
|
|
)),
|
|
created_at: std::option::Option::Some(yellowstone_grpc_proto::prost_types::Timestamp { seconds: 6, nanos: 7 }),
|
|
};
|
|
let entry = super::decode_entry_update(entry_wire).expect("entry update must decode");
|
|
assert_eq!(entry.filters()[0].as_str(), "entries");
|
|
assert_eq!(entry.entry().slot(), 900);
|
|
assert_eq!(entry.entry().index(), 3);
|
|
assert_eq!(entry.entry().num_hashes(), 4);
|
|
assert_eq!(entry.entry().hash().as_bytes(), &[43_u8; 32]);
|
|
assert_eq!(entry.entry().executed_transaction_count(), 5);
|
|
assert_eq!(entry.entry().starting_transaction_index(), 0);
|
|
assert!(!format!("{entry:?}").contains("43, 43"));
|
|
let malformed_entry = yellowstone_grpc_proto::geyser::SubscribeUpdate {
|
|
filters: vec!["entries".to_owned()],
|
|
update_oneof: std::option::Option::Some(yellowstone_grpc_proto::geyser::subscribe_update::UpdateOneof::Entry(
|
|
yellowstone_grpc_proto::geyser::SubscribeUpdateEntry {
|
|
slot: 1,
|
|
index: 0,
|
|
num_hashes: 0,
|
|
hash: vec![0_u8; 31],
|
|
executed_transaction_count: 0,
|
|
starting_transaction_index: 0,
|
|
},
|
|
)),
|
|
created_at: std::option::Option::None,
|
|
};
|
|
assert!(super::decode_entry_update(malformed_entry).is_err());
|
|
}
|