309 lines
12 KiB
Rust
309 lines
12 KiB
Rust
// file: crates/ksp-worker-raw-transaction-ingest-lib/tests/dependency_boundary.rs
|
|
// version: 13
|
|
|
|
//! Dependency firewall canaries for the RAW transaction ingest Worker foundation.
|
|
|
|
#[test]
|
|
fn pre_002_manifest_dependency_surface_is_exact() {
|
|
let manifest = include_str!("../Cargo.toml");
|
|
let dependencies = dependency_section(manifest);
|
|
let names = manifest_dependency_names(dependencies);
|
|
assert_eq!(
|
|
names,
|
|
vec![
|
|
"ksp-core-lib",
|
|
"ksp-logging-lib",
|
|
"ksp-onchain-transport-lib",
|
|
"ksp-raw-transaction-lib",
|
|
"ksp-store-lib",
|
|
"ksp-worker-api",
|
|
"sha2",
|
|
"tokio",
|
|
],
|
|
);
|
|
for required in [
|
|
"ksp-core-lib = { path = \"../ksp-core-lib\" }",
|
|
"ksp-logging-lib = { path = \"../ksp-logging-lib\" }",
|
|
"ksp-onchain-transport-lib = { path = \"../ksp-onchain-transport-lib\" }",
|
|
"ksp-raw-transaction-lib = { path = \"../ksp-raw-transaction-lib\" }",
|
|
"ksp-store-lib = { path = \"../ksp-store-lib\", default-features = false }",
|
|
"ksp-worker-api = { path = \"../ksp-worker-api\" }",
|
|
"sha2 = { workspace = true }",
|
|
"tokio = { workspace = true, features = [\"macros\", \"rt\", \"sync\", \"time\"] }",
|
|
] {
|
|
assert!(dependencies.contains(required), "required Worker dependency missing: {required}");
|
|
}
|
|
return;
|
|
}
|
|
|
|
#[test]
|
|
fn v0_3_12_pre_002_manifest_opens_only_the_onchain_transport_live_source_edge() {
|
|
let manifest = include_str!("../Cargo.toml");
|
|
let dependencies = dependency_section(manifest);
|
|
for forbidden in [
|
|
"futures-util",
|
|
"ksp-config-lib",
|
|
"ksp-interface-lib",
|
|
"ksp-job-api",
|
|
"ksp-job-backfill-lib",
|
|
"ksp-program-api",
|
|
"ksp-store-api",
|
|
"ksp-store-postgres-lib",
|
|
"ksp-wallet-lib",
|
|
"reqwest",
|
|
"solana-",
|
|
"tokio-tungstenite",
|
|
"tonic",
|
|
"yellowstone-grpc-proto",
|
|
] {
|
|
assert!(!dependencies.contains(forbidden), "forbidden Worker dependency present: {forbidden}");
|
|
}
|
|
assert!(!manifest.contains("[dev-dependencies]"), "foundation requires no test-only dependency");
|
|
assert!(!manifest.contains("[build-dependencies]"), "foundation requires no build dependency");
|
|
return;
|
|
}
|
|
|
|
#[test]
|
|
fn v0_3_12_pre_003_transaction_and_status_adapters_are_private_and_transport_facade_only() {
|
|
let root = include_str!("../src/lib.rs");
|
|
let resources = include_str!("../src/runtime_resources.rs");
|
|
for required in [
|
|
"RawTransactionIngestYellowstoneSignalView for ksp_onchain_transport_lib::YellowstoneTransactionUpdate",
|
|
"RawTransactionIngestYellowstoneSignalView for ksp_onchain_transport_lib::YellowstoneTransactionStatusUpdate",
|
|
"YellowstoneTransactionUpdate::transaction(self).signature()",
|
|
"YellowstoneTransactionUpdate::transaction(self).index()",
|
|
"YellowstoneTransactionStatusUpdate::signature(self)",
|
|
"YellowstoneTransactionStatusUpdate::index(self)",
|
|
"RawTransactionSignature::new",
|
|
"matched_filter_fingerprint",
|
|
"yellowstone_provider_unrepresentable",
|
|
"yellowstone_endpoint_unrepresentable",
|
|
] {
|
|
assert!(resources.contains(required), "required pre.003 signal-adapter contract missing: {required}");
|
|
}
|
|
for forbidden in [
|
|
"pub struct RawTransactionIngestSourceSignal",
|
|
"pub(crate) struct RawTransactionIngestSourceSignal",
|
|
"pub use self::runtime_resources::RawTransactionIngestSourceSignal",
|
|
"get_block_observed",
|
|
"ksp_store_postgres_lib::",
|
|
"reqwest::",
|
|
"tonic::",
|
|
"yellowstone_grpc_proto::",
|
|
] {
|
|
assert!(!resources.contains(forbidden) && !root.contains(forbidden), "pre.003 crossed a private/offline boundary: {forbidden}");
|
|
}
|
|
let status_impl =
|
|
match resources.split_once("impl RawTransactionIngestYellowstoneSignalView for ksp_onchain_transport_lib::YellowstoneTransactionStatusUpdate") {
|
|
std::option::Option::Some((_, tail)) => match tail.split_once("impl std::convert::From<") {
|
|
std::option::Option::Some((value, _)) => value,
|
|
std::option::Option::None => tail,
|
|
},
|
|
std::option::Option::None => "",
|
|
};
|
|
assert!(!status_impl.contains("::error(self)"), "TransactionStatus remote error material must not enter the private signal");
|
|
return;
|
|
}
|
|
|
|
#[test]
|
|
fn v0_3_12_pre_004_hydration_contract_uses_only_transport_facade_common_raw_and_existing_ingress() {
|
|
let root = include_str!("../src/lib.rs");
|
|
let resources = include_str!("../src/runtime_resources.rs");
|
|
for required in [
|
|
"get_transaction_observed",
|
|
"SolanaGetTransactionConfig::new",
|
|
"SolanaTransactionEncoding::Base64",
|
|
"format_raw_transaction_signature",
|
|
"extract_raw_transaction_signature_from_binary_base64",
|
|
"RawTransactionMaterial::binary_base64",
|
|
"RawTransactionIngress",
|
|
"yellowstone_http",
|
|
"transaction_get_transaction",
|
|
"status_get_transaction",
|
|
"RawAcquisitionOrigin::Live",
|
|
"composite_provenance_codes",
|
|
] {
|
|
assert!(resources.contains(required), "required pre.004 hydration contract missing: {required}");
|
|
}
|
|
assert!(resources.contains("fn finalize_yellowstone_hydration"));
|
|
assert!(resources.contains("fn fetch_yellowstone_hydration"));
|
|
for forbidden in [
|
|
"get_block_observed",
|
|
"ksp_config_lib::",
|
|
"ksp_job_backfill_lib::",
|
|
"ksp_store_postgres_lib::",
|
|
"reqwest::",
|
|
"tonic::",
|
|
"yellowstone_grpc_proto::",
|
|
] {
|
|
assert!(!resources.contains(forbidden) && !root.contains(forbidden), "pre.004 crossed a forbidden boundary: {forbidden}");
|
|
}
|
|
return;
|
|
}
|
|
|
|
#[test]
|
|
fn v0_3_12_pre_005_block_and_continuity_adapters_remain_private_and_transport_facade_only() {
|
|
let root = include_str!("../src/lib.rs");
|
|
let resources = include_str!("../src/runtime_resources.rs");
|
|
for required in [
|
|
"RawTransactionIngestYellowstoneBlockView",
|
|
"YellowstoneBlockUpdate",
|
|
"project_yellowstone_block_signals",
|
|
"RawTransactionIngestYellowstoneContinuityView",
|
|
"YellowstoneBlockMetaUpdate",
|
|
"YellowstoneSlotUpdate",
|
|
"RawTransactionIngestContinuitySignal",
|
|
"block_get_transaction",
|
|
] {
|
|
assert!(resources.contains(required), "required pre.005 private adapter contract missing: {required}");
|
|
}
|
|
for forbidden in [
|
|
"get_block_observed",
|
|
"ksp_config_lib::",
|
|
"ksp_job_backfill_lib::",
|
|
"ksp_store_postgres_lib::",
|
|
"reqwest::",
|
|
"tonic::",
|
|
"yellowstone_grpc_proto::",
|
|
] {
|
|
assert!(!resources.contains(forbidden) && !root.contains(forbidden), "pre.005 crossed a forbidden boundary: {forbidden}");
|
|
}
|
|
return;
|
|
}
|
|
|
|
#[test]
|
|
fn v0_3_12_pre_006_productive_source_uses_transport_session_bounded_coalescence_and_existing_admission() {
|
|
let runtime = include_str!("../src/runtime.rs");
|
|
let resources = include_str!("../src/runtime_resources.rs");
|
|
for required in ["runtime_resources.into_yellowstone_source()", "children.spawn", "source.run(source_settings, stop_receiver, admission_sender)"] {
|
|
assert!(runtime.contains(required), "required pre.006 supervisor wiring missing: {required}");
|
|
}
|
|
for required in [
|
|
"open_standard_subscribe",
|
|
"next_update",
|
|
"RawTransactionIngestHydrationCoordinator",
|
|
"std::collections::BTreeMap",
|
|
"tokio::task::JoinSet",
|
|
"MAX_RAW_TRANSACTION_INGEST_ADMISSION_QUEUE_CAPACITY",
|
|
"get_transaction_observed",
|
|
"admission_sender.send(ingress)",
|
|
"tasks.abort_all()",
|
|
"session.close().await",
|
|
"commitment: commitment.as_str()",
|
|
"network: signal.network.clone()",
|
|
"signature: signal.signature",
|
|
] {
|
|
assert!(resources.contains(required), "required pre.006 productive-source contract missing: {required}");
|
|
}
|
|
for forbidden in [
|
|
"get_block_observed",
|
|
"ksp_config_lib::",
|
|
"ksp_job_backfill_lib::",
|
|
"ksp_store_postgres_lib::",
|
|
"reqwest::",
|
|
"tonic::",
|
|
"yellowstone_grpc_proto::",
|
|
"unbounded_channel",
|
|
] {
|
|
assert!(!runtime.contains(forbidden) && !resources.contains(forbidden), "pre.006 crossed a forbidden productive-source boundary: {forbidden}");
|
|
}
|
|
return;
|
|
}
|
|
|
|
#[test]
|
|
fn v0_3_12_pre_006_source_surface_hardens_shutdown_and_faults_without_backend_edges() {
|
|
let root = include_str!("../src/lib.rs");
|
|
let runtime = include_str!("../src/runtime.rs");
|
|
let admission = include_str!("../src/admission.rs");
|
|
let persistence = include_str!("../src/persistence.rs");
|
|
let snapshot = include_str!("../src/snapshot.rs");
|
|
let runtime_resources = include_str!("../src/runtime_resources.rs");
|
|
for required in [
|
|
"tokio::sync::mpsc::channel",
|
|
"canonicalize_raw_transaction",
|
|
"assemble_raw_transaction_acquisition",
|
|
"RawTransactionIngestPersistencePort",
|
|
"RawTransactionAcquisitionMode::Normal",
|
|
"RawTransactionIngestSnapshot",
|
|
"RawTransactionIngestSnapshotSource",
|
|
"WorkerSnapshotSource",
|
|
"tokio::sync::watch::channel",
|
|
"ERROR_CODE_RAW_TRANSACTION_INGEST_COUNTER_EXHAUSTED",
|
|
"ERROR_CODE_RAW_TRANSACTION_INGEST_DRAIN_TIMEOUT",
|
|
"ERROR_CODE_RAW_TRANSACTION_INGEST_SOURCE_FAILED",
|
|
"record_source_failure",
|
|
"tokio::time::timeout",
|
|
"abort_all",
|
|
"backpressure_wait_total",
|
|
] {
|
|
assert!(
|
|
root.contains(required)
|
|
|| runtime.contains(required)
|
|
|| admission.contains(required)
|
|
|| persistence.contains(required)
|
|
|| snapshot.contains(required)
|
|
|| runtime_resources.contains(required),
|
|
"required pre.009 hardening contract missing: {required}"
|
|
);
|
|
}
|
|
for forbidden in [
|
|
"pub use self::admission::RawTransactionAdmission",
|
|
"pub use self::admission::RawTransactionIngress",
|
|
"pub use self::persistence::RawTransactionIngestPersistencePort",
|
|
"unbounded_channel",
|
|
"ksp_store_postgres_lib::",
|
|
"ForceRehydrate",
|
|
"ksp_config_lib::",
|
|
"reqwest::",
|
|
] {
|
|
assert!(
|
|
!root.contains(forbidden)
|
|
&& !runtime.contains(forbidden)
|
|
&& !admission.contains(forbidden)
|
|
&& !persistence.contains(forbidden)
|
|
&& !snapshot.contains(forbidden)
|
|
&& !runtime_resources.contains(forbidden),
|
|
"pre.009 crossed a forbidden runtime boundary: {forbidden}"
|
|
);
|
|
}
|
|
assert_eq!(runtime.matches("tokio::sync::watch::channel").count(), 2, "runtime retains only the external-control and private-source stop watches");
|
|
assert_eq!(snapshot.matches("tokio::sync::watch::channel").count(), 1, "exactly one shared concrete snapshot watch is allowed");
|
|
return;
|
|
}
|
|
|
|
fn dependency_section(manifest: &str) -> &str {
|
|
let after_header = match manifest.split_once("[dependencies]") {
|
|
std::option::Option::Some((_, section)) => section,
|
|
std::option::Option::None => {
|
|
return "";
|
|
},
|
|
};
|
|
let end = match after_header.find("\n[") {
|
|
std::option::Option::Some(index) => index,
|
|
std::option::Option::None => after_header.len(),
|
|
};
|
|
return &after_header[..end];
|
|
}
|
|
|
|
fn manifest_dependency_names(section: &str) -> std::vec::Vec<&str> {
|
|
let mut names = std::vec::Vec::new();
|
|
for line in section.lines() {
|
|
let content = match line.split('#').next() {
|
|
std::option::Option::Some(value) => value.trim(),
|
|
std::option::Option::None => continue,
|
|
};
|
|
if content.is_empty() {
|
|
continue;
|
|
}
|
|
let name = match content.split('=').next() {
|
|
std::option::Option::Some(value) => value.trim().trim_end_matches(".workspace"),
|
|
std::option::Option::None => continue,
|
|
};
|
|
if !name.is_empty() {
|
|
names.push(name);
|
|
}
|
|
}
|
|
names.sort_unstable();
|
|
return names;
|
|
}
|