v0.3.13-pre.003

crates/ksp-worker-raw-transaction-ingest-lib/src/lib.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-worker-raw-transaction-ingest-lib/src/lib.rs
-// version: 19
+// version: 20
 
 #![warn(missing_docs)]
 #![deny(unreachable_pub)]
@@ -10,12 +10,11 @@
 //! This tranche owns the concrete Worker family identity, validated technical settings
 //! and the caller-runtime-owned lifecycle with private child-task supervision. This tranche also
 //! owns bounded source-neutral admission, common RAW canonicalization/assembly and backend-neutral
-//! Store persistence in normal mode plus concrete latest-value snapshots projected onto Worker API. `pre.002` adds a bounded 1..32 caller-composed live-source
-//! aggregate with deterministic logical source identities while deliberately keeping productive multi-source activation gated until the supervisor tranche; the
-//! validated Yellowstone/HTTP runtime-resource contract still drives the only productive supervised source task.
-//! Transaction/TransactionStatus/Block updates feed bounded HTTP `getTransaction` hydration and the existing central
-//! admission path; BlockMeta/Slot remain continuity-only signals. Hydration is coalesced by network/signature/commitment
-//! under bounded in-flight and pending budgets. A bounded run-local processing frontier projects hydration pending,
+//! Store persistence in normal mode plus concrete latest-value snapshots projected onto Worker API. `pre.003` keeps the bounded 1..32 caller-composed
+//! aggregate and adds a productive standard Solana `logsSubscribe` + observed HTTP `getTransaction` source beside Yellowstone while simultaneous multi-source
+//! activation remains gated until the dedicated supervisor tranche. Both live source families converge into one source-neutral hydration coordinator contract and
+//! the existing central admission path. Yellowstone Transaction/TransactionStatus/Block and standard logs notifications become signature/slot references;
+//! BlockMeta/Slot remain continuity-only signals. Hydration is coalesced by network/signature/commitment under bounded in-flight and pending budgets. A bounded run-local processing frontier projects hydration pending,
 //! oldest pending slot and highest unblocked actually observed slot. The productive source now also projects safe Transport reconnect/replay state and faults
 //! conservatively when Transport proves a replay-retention continuity gap; history remediation remains outside this crate.
 
@@ -52,8 +51,10 @@ pub use self::runtime::RawTransactionIngestTerminalFuture;
 pub use self::runtime::RawTransactionIngestWorker;
 /// Maximum number of logical live sources accepted by one runtime-resource aggregate.
 pub use self::runtime_resources::MAX_RAW_TRANSACTION_INGEST_LIVE_SOURCES;
-/// Caller-composed runtime resources for the first Yellowstone + HTTP source family.
+/// Caller-composed bounded runtime resources for supported continuous RAW transaction live-source families.
 pub use self::runtime_resources::RawTransactionIngestRuntimeResources;
+/// Validated standard Solana `logsSubscribe` + HTTP hydration source contract owned by the continuous RAW transaction ingest Worker.
+pub use self::runtime_resources::RawTransactionIngestStandardLogsSource;
 /// Validated Yellowstone + HTTP source contract owned by the continuous RAW transaction ingest Worker.
 pub use self::runtime_resources::RawTransactionIngestYellowstoneSource;
 /// Default bounded admission queue capacity for one RAW transaction ingest Worker.

crates/ksp-worker-raw-transaction-ingest-lib/src/runtime.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-worker-raw-transaction-ingest-lib/src/runtime.rs
-// version: 12
+// version: 13
 
 type PersistencePort = std::sync::Arc<dyn crate::RawTransactionIngestPersistencePort + 'static>;
 type PersistenceTasks = tokio::task::JoinSet<ksp_core_lib::Result<crate::RawTransactionIngestPersistenceOutcome>>;
@@ -99,8 +99,8 @@ impl crate::RawTransactionIngestWorker {
 
     /// Starts one Worker with caller-composed runtime resources.
     ///
-    /// `pre.002` accepts a validated multi-source aggregate but intentionally activates only the existing single-Yellowstone supervisor path; aggregates with
-    /// more than one source fail closed before any source task is spawned.
+    /// `pre.003` activates either the existing Yellowstone source or one standard Solana `logsSubscribe` source through the same bounded Worker foundation.
+    /// Aggregates with more than one source still fail closed before any source task is spawned until the dedicated simultaneous supervisor tranche.
     pub fn start_with_runtime_resources(
         settings: crate::RawTransactionIngestSettings,
         store: std::sync::Arc<ksp_store_lib::Store>,
@@ -117,10 +117,9 @@ impl crate::RawTransactionIngestWorker {
         if let std::result::Result::Err(error) = runtime_resources.validate_network(settings.network()) {
             return std::result::Result::Err(error);
         }
-        let source = match runtime_resources.into_yellowstone_source() {
-            std::result::Result::Ok(value) => value,
-            std::result::Result::Err(error) => return std::result::Result::Err(error),
-        };
+        if let std::result::Result::Err(error) = runtime_resources.validate_single_source_activation() {
+            return std::result::Result::Err(error);
+        }
         let source_settings = settings.clone();
         let (processing_frontier_sender, processing_frontier_receiver) =
             tokio::sync::watch::channel(crate::RawTransactionIngestProcessingFrontierProjection::empty());
@@ -132,7 +131,7 @@ impl crate::RawTransactionIngestWorker {
             std::option::Option::Some(processing_frontier_receiver),
             move |children, stop_receiver, admission_sender| {
                 let _abort_handle = children.spawn(async move {
-                    return source.run(source_settings, stop_receiver, admission_sender, processing_frontier_sender).await;
+                    return runtime_resources.run_single_live_source(source_settings, stop_receiver, admission_sender, processing_frontier_sender).await;
                 });
             },
         );

crates/ksp-worker-raw-transaction-ingest-lib/src/runtime_resources.rs

@@ -1,5 +1,5 @@
 // file: crates/ksp-worker-raw-transaction-ingest-lib/src/runtime_resources.rs
-// version: 13
+// version: 14
 
 use sha2::Digest; // rust-rules: trait-import
 
@@ -7,6 +7,9 @@ use sha2::Digest; // rust-rules: trait-import
 pub const MAX_RAW_TRANSACTION_INGEST_LIVE_SOURCES: usize = 32;
 
 const RAW_TRANSACTION_INGEST_LIVE_SOURCE_KEY_DOMAIN: &[u8] = b"ksp.raw_transaction_ingest.live_source.source_key.v1\0";
+const RAW_TRANSACTION_INGEST_STANDARD_LOGS_FILTER_FINGERPRINT_DOMAIN: &[u8] = b"ksp.raw_transaction_ingest.standard_logs.filter.v1\0";
+const RAW_TRANSACTION_INGEST_STANDARD_LOGS_HTTP_PROTOCOL: &str = "solana_ws_http";
+const RAW_TRANSACTION_INGEST_STANDARD_LOGS_HTTP_SOURCE_KEY_DOMAIN: &[u8] = b"ksp.raw_transaction_ingest.standard_logs_http.source_key.v1\0";
 const RAW_TRANSACTION_INGEST_YELLOWSTONE_FILTER_FINGERPRINT_DOMAIN: &[u8] = b"ksp.raw_transaction_ingest.yellowstone.filters.v1\0";
 const RAW_TRANSACTION_INGEST_YELLOWSTONE_HTTP_PROTOCOL: &str = "yellowstone_http";
 const RAW_TRANSACTION_INGEST_YELLOWSTONE_HTTP_SOURCE_KEY_DOMAIN: &[u8] = b"ksp.raw_transaction_ingest.yellowstone_http.source_key.v1\0";
@@ -14,26 +17,43 @@ const RAW_TRANSACTION_INGEST_YELLOWSTONE_HTTP_SOURCE_KEY_DOMAIN: &[u8] = b"ksp.r
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 enum RawTransactionIngestSourceFamily {
     Block,
+    Logs,
     Transaction,
     TransactionStatus,
 }
 
 enum RawTransactionIngestLiveSource {
+    StandardLogs(crate::RawTransactionIngestStandardLogsSource),
     Yellowstone(crate::RawTransactionIngestYellowstoneSource),
 }
 
 impl RawTransactionIngestLiveSource {
     fn network(&self) -> &ksp_store_lib::RawNetworkId {
         return match self {
+            Self::StandardLogs(source) => &source.network,
             Self::Yellowstone(source) => &source.network,
         };
     }
 
     fn source_key(&self) -> [u8; 32] {
         return match self {
+            Self::StandardLogs(source) => source.source_key,
             Self::Yellowstone(source) => source.source_key,
         };
     }
+
+    async fn run(
+        self,
+        settings: crate::RawTransactionIngestSettings,
+        stop_receiver: tokio::sync::watch::Receiver<bool>,
+        admission_sender: tokio::sync::mpsc::Sender<crate::RawTransactionIngress>,
+        processing_frontier_sender: tokio::sync::watch::Sender<crate::RawTransactionIngestProcessingFrontierProjection>,
+    ) -> ksp_core_lib::Result<()> {
+        return match self {
+            Self::StandardLogs(source) => source.run(settings, stop_receiver, admission_sender, processing_frontier_sender).await,
+            Self::Yellowstone(source) => source.run(settings, stop_receiver, admission_sender, processing_frontier_sender).await,
+        };
+    }
 }
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
@@ -321,6 +341,18 @@ impl std::convert::From<(&crate::RawTransactionIngestYellowstoneSource, &ksp_onc
     }
 }
 
+#[derive(Clone)]
+struct RawTransactionIngestHydrationContext {
+    commitment: ksp_onchain_transport_lib::SolanaCommitment,
+    http_pool: ksp_onchain_transport_lib::HttpTransportPool,
+    hydration_role: ksp_onchain_transport_lib::HttpRoleName,
+    network: ksp_store_lib::RawNetworkId,
+    protocol: &'static str,
+    route: RawTransactionIngestSourceRoute,
+    route_prefix: &'static str,
+    source_key_domain: &'static [u8],
+}
+
 /// Validated Yellowstone plus HTTP runtime source owned by the continuous RAW transaction ingest Worker.
 ///
 /// The Transport-owned channel, subscribe request, HTTP pool and hydration role remain private. Construction validates deterministic source-composition
@@ -373,7 +405,7 @@ impl crate::RawTransactionIngestYellowstoneSource {
             std::option::Option::Some(value) => value,
             std::option::Option::None => return std::result::Result::Err(crate::runtime_error("runtime_resources.hydration_method_missing")),
         };
-        let compatible_http_routes = compatible_http_route_count(&http_pool, &hydration_role, method.request_kind(), network.as_str(), &route);
+        let compatible_http_routes = compatible_http_route_count(&http_pool, &hydration_role, method.request_kind(), network.as_str(), &route, "ys");
         let compatible_http_routes = match compatible_http_routes {
             std::result::Result::Ok(value) => value,
             std::result::Result::Err(error) => return std::result::Result::Err(error),
@@ -389,6 +421,23 @@ impl crate::RawTransactionIngestYellowstoneSource {
         return std::result::Result::Ok(Self { yellowstone_channel, subscribe_request, http_pool, hydration_role, network, route, source_key });
     }
 
+    fn hydration_context(&self) -> RawTransactionIngestHydrationContext {
+        let commitment = match self.subscribe_request.commitment() {
+            std::option::Option::Some(value) => value,
+            std::option::Option::None => ksp_onchain_transport_lib::SolanaCommitment::Confirmed,
+        };
+        return RawTransactionIngestHydrationContext {
+            commitment,
+            http_pool: self.http_pool.clone(),
+            hydration_role: self.hydration_role.clone(),
+            network: self.network.clone(),
+            protocol: RAW_TRANSACTION_INGEST_YELLOWSTONE_HTTP_PROTOCOL,
+            route: self.route.clone(),
+            route_prefix: "ys",
+            source_key_domain: RAW_TRANSACTION_INGEST_YELLOWSTONE_HTTP_SOURCE_KEY_DOMAIN,
+        };
+    }
+
     /// Runs the productive Yellowstone source task until cooperative stop or one safe terminal source failure.
     pub(crate) async fn run(
         self,
@@ -408,6 +457,7 @@ impl crate::RawTransactionIngestYellowstoneSource {
             std::result::Result::Ok(value) => value,
             std::result::Result::Err(error) => return std::result::Result::Err(source_transport_error(error.code())),
         };
+        let hydration = self.hydration_context();
         let mut coordinator = RawTransactionIngestHydrationCoordinator::new(&settings);
         let mut processing_frontier = RawTransactionIngestProcessingFrontierReporter::new(processing_frontier_sender);
         let snapshot_source = session.snapshot_source();
@@ -422,7 +472,7 @@ impl crate::RawTransactionIngestYellowstoneSource {
             if *stop_receiver.borrow() {
                 break;
             }
-            if let std::result::Result::Err(error) = coordinator.start_hydrations(&self) {
+            if let std::result::Result::Err(error) = coordinator.start_hydrations(&hydration) {
                 fault = std::option::Option::Some(error);
                 break;
             }
@@ -460,7 +510,7 @@ impl crate::RawTransactionIngestYellowstoneSource {
                     let handled = coordinator
                         .handle_joined(
                             joined,
-                            &self,
+                            &hydration,
                             &settings,
                             &admission_sender,
                             &mut stop_receiver,
@@ -490,6 +540,7 @@ impl crate::RawTransactionIngestYellowstoneSource {
                     };
                     if let std::result::Result::Err(error) = route_yellowstone_update(
                         &self,
+                        &hydration,
                         &mut coordinator,
                         &mut processing_frontier,
                         update,
@@ -520,6 +571,258 @@ impl crate::RawTransactionIngestYellowstoneSource {
     }
 }
 
+/// Validated standard Solana `logsSubscribe` plus HTTP hydration source owned by the continuous RAW transaction ingest Worker.
+///
+/// The caller provides one Transport-owned standard WebSocket endpoint, one standard logs filter, a Confirmed/Finalized commitment and one HTTP hydration
+/// pool/role. The source keeps the WebSocket URL and filter private, never copies remote logs/errors into Worker state, and emits only signature/slot
+/// references into the source-neutral hydration coordinator.
+pub struct RawTransactionIngestStandardLogsSource {
+    ws_endpoint: ksp_onchain_transport_lib::WsEndpointSettings,
+    filter: ksp_onchain_transport_lib::SolanaLogsSubscribeFilter,
+    commitment: ksp_onchain_transport_lib::SolanaCommitment,
+    http_pool: ksp_onchain_transport_lib::HttpTransportPool,
+    hydration_role: ksp_onchain_transport_lib::HttpRoleName,
+    network: ksp_store_lib::RawNetworkId,
+    route: RawTransactionIngestSourceRoute,
+    filter_fingerprint: [u8; 32],
+    source_key: [u8; 32],
+}
+
+impl crate::RawTransactionIngestStandardLogsSource {
+    /// Creates one validated standard Solana logs source without opening WebSocket or HTTP network I/O.
+    pub fn new(
+        ws_endpoint: ksp_onchain_transport_lib::WsEndpointSettings,
+        filter: ksp_onchain_transport_lib::SolanaLogsSubscribeFilter,
+        commitment: ksp_onchain_transport_lib::SolanaCommitment,
+        http_pool: ksp_onchain_transport_lib::HttpTransportPool,
+        hydration_role: ksp_onchain_transport_lib::HttpRoleName,
+    ) -> ksp_core_lib::Result<Self> {
+        let ws_settings = ksp_onchain_transport_lib::WsTransportSettings::new(std::vec![ws_endpoint.clone()]);
+        if ws_settings.validate().is_err() {
+            return std::result::Result::Err(crate::runtime_error("runtime_resources.standard_logs_endpoint_invalid"));
+        }
+        if ws_endpoint.protocol() != ksp_onchain_transport_lib::WsProtocolKind::SolanaStandard {
+            return std::result::Result::Err(crate::runtime_error("runtime_resources.standard_logs_protocol_invalid"));
+        }
+        match commitment {
+            ksp_onchain_transport_lib::SolanaCommitment::Confirmed | ksp_onchain_transport_lib::SolanaCommitment::Finalized => {},
+            ksp_onchain_transport_lib::SolanaCommitment::Processed => {
+                return std::result::Result::Err(crate::runtime_error("runtime_resources.hydration_commitment_invalid"));
+            },
+        }
+        let network = match ksp_store_lib::RawNetworkId::new(ws_endpoint.cluster().as_str()) {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(_) => return std::result::Result::Err(crate::runtime_error("runtime_resources.standard_logs_network_unrepresentable")),
+        };
+        let provider = match ksp_store_lib::RawProvenanceCode::new(ws_endpoint.provider().as_str()) {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(_) => return std::result::Result::Err(crate::runtime_error("runtime_resources.standard_logs_provider_unrepresentable")),
+        };
+        let endpoint_id = match ksp_store_lib::RawProvenanceCode::new(ws_endpoint.name()) {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(_) => return std::result::Result::Err(crate::runtime_error("runtime_resources.standard_logs_endpoint_unrepresentable")),
+        };
+        let route = RawTransactionIngestSourceRoute { endpoint_id, provider };
+        let method = match ksp_onchain_transport_lib::find_http_rpc_method("getTransaction") {
+            std::option::Option::Some(value) => value,
+            std::option::Option::None => return std::result::Result::Err(crate::runtime_error("runtime_resources.hydration_method_missing")),
+        };
+        let compatible_http_routes = compatible_http_route_count(&http_pool, &hydration_role, method.request_kind(), network.as_str(), &route, "ws");
+        let compatible_http_routes = match compatible_http_routes {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(error),
+        };
+        if compatible_http_routes == 0 {
+            return std::result::Result::Err(crate::runtime_error("runtime_resources.hydration_role_unsupported"));
+        }
+        let filter_fingerprint = standard_logs_filter_fingerprint(&filter);
+        let source_key = standard_logs_live_source_key(&network, &route, commitment, &filter_fingerprint);
+        return std::result::Result::Ok(Self {
+            ws_endpoint,
+            filter,
+            commitment,
+            http_pool,
+            hydration_role,
+            network,
+            route,
+            filter_fingerprint,
+            source_key,
+        });
+    }
+
+    fn hydration_context(&self) -> RawTransactionIngestHydrationContext {
+        return RawTransactionIngestHydrationContext {
+            commitment: self.commitment,
+            http_pool: self.http_pool.clone(),
+            hydration_role: self.hydration_role.clone(),
+            network: self.network.clone(),
+            protocol: RAW_TRANSACTION_INGEST_STANDARD_LOGS_HTTP_PROTOCOL,
+            route: self.route.clone(),
+            route_prefix: "ws",
+            source_key_domain: RAW_TRANSACTION_INGEST_STANDARD_LOGS_HTTP_SOURCE_KEY_DOMAIN,
+        };
+    }
+
+    /// Runs one productive standard `logsSubscribe` source until cooperative stop or one safe terminal source failure.
+    pub(crate) async fn run(
+        self,
+        settings: crate::RawTransactionIngestSettings,
+        mut stop_receiver: tokio::sync::watch::Receiver<bool>,
+        admission_sender: tokio::sync::mpsc::Sender<crate::RawTransactionIngress>,
+        processing_frontier_sender: tokio::sync::watch::Sender<crate::RawTransactionIngestProcessingFrontierProjection>,
+    ) -> ksp_core_lib::Result<()> {
+        let connected = tokio::select! {
+            biased;
+            _ = stop_receiver.changed() => {
+                return std::result::Result::Ok(());
+            }
+            result = ksp_onchain_transport_lib::SolanaStandardWsSession::connect(self.ws_endpoint.clone()) => result,
+        };
+        let session = match connected {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => return std::result::Result::Err(source_transport_error(error.code())),
+        };
+        let config = ksp_onchain_transport_lib::SolanaCommitmentConfig::new(std::option::Option::Some(self.commitment));
+        let subscribed = tokio::select! {
+            biased;
+            _ = stop_receiver.changed() => {
+                let _closed = session.close().await;
+                return std::result::Result::Ok(());
+            }
+            result = session.logs_subscribe(&self.filter, std::option::Option::Some(&config)) => result,
+        };
+        let mut subscription = match subscribed {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => {
+                let _closed = session.close().await;
+                return std::result::Result::Err(source_transport_error(error.code()));
+            },
+        };
+        let hydration = self.hydration_context();
+        let mut coordinator = RawTransactionIngestHydrationCoordinator::new(&settings);
+        let mut processing_frontier = RawTransactionIngestProcessingFrontierReporter::new(processing_frontier_sender);
+        processing_frontier.set_source_state(crate::RawTransactionIngestSourceState::Active);
+        let mut fault = std::option::Option::None;
+        loop {
+            if *stop_receiver.borrow() {
+                break;
+            }
+            if let std::result::Result::Err(error) = coordinator.start_hydrations(&hydration) {
+                fault = std::option::Option::Some(error);
+                break;
+            }
+            let can_receive = coordinator.can_receive();
+            if !can_receive && coordinator.tasks.is_empty() {
+                fault = std::option::Option::Some(crate::runtime_error("source.hydration_stalled"));
+                break;
+            }
+            tokio::select! {
+                biased;
+                _ = stop_receiver.changed() => {
+                    break;
+                }
+                joined = coordinator.tasks.join_next(), if !coordinator.tasks.is_empty() => {
+                    let joined = match joined {
+                        std::option::Option::Some(value) => value,
+                        std::option::Option::None => {
+                            fault = std::option::Option::Some(crate::runtime_error("source.hydration_join_missing"));
+                            break;
+                        },
+                    };
+                    let handled = coordinator
+                        .handle_joined(
+                            joined,
+                            &hydration,
+                            &settings,
+                            &admission_sender,
+                            &mut stop_receiver,
+                            &mut processing_frontier,
+                        )
+                        .await;
+                    match handled {
+                        std::result::Result::Ok(true) => {},
+                        std::result::Result::Ok(false) => break,
+                        std::result::Result::Err(error) => {
+                            fault = std::option::Option::Some(error);
+                            break;
+                        },
+                    }
+                }
+                notification = subscription.recv(), if can_receive => {
+                    let notification = match notification {
+                        std::option::Option::Some(std::result::Result::Ok(value)) => value,
+                        std::option::Option::Some(std::result::Result::Err(error)) => {
+                            fault = std::option::Option::Some(source_transport_error(error.code()));
+                            break;
+                        },
+                        std::option::Option::None => {
+                            let error = match subscription.terminal_error_code() {
+                                std::option::Option::Some(code) => source_transport_error(code),
+                                std::option::Option::None => crate::runtime_error("source.standard_logs_subscription_closed"),
+                            };
+                            fault = std::option::Option::Some(error);
+                            break;
+                        },
+                    };
+                    let received_at = match current_raw_timestamp() {
+                        std::result::Result::Ok(value) => value,
+                        std::result::Result::Err(error) => {
+                            fault = std::option::Option::Some(error);
+                            break;
+                        },
+                    };
+                    let signal = match project_standard_logs_signal(&self, &notification) {
+                        std::result::Result::Ok(value) => value,
+                        std::result::Result::Err(error) => {
+                            fault = std::option::Option::Some(error);
+                            break;
+                        },
+                    };
+                    if let std::result::Result::Err(error) = coordinator.queue_signal(&hydration, signal, received_at, &mut processing_frontier) {
+                        fault = std::option::Option::Some(error);
+                        break;
+                    }
+                }
+            }
+        }
+        coordinator.abort_all(&mut processing_frontier).await;
+        processing_frontier.set_source_state(crate::RawTransactionIngestSourceState::Closing);
+        let closed = session.close().await;
+        if let std::option::Option::Some(error) = fault {
+            processing_frontier.set_source_state(crate::RawTransactionIngestSourceState::Failed);
+            return std::result::Result::Err(error);
+        }
+        return match closed {
+            std::result::Result::Ok(()) => {
+                processing_frontier.set_source_state(crate::RawTransactionIngestSourceState::Closed);
+                std::result::Result::Ok(())
+            },
+            std::result::Result::Err(error) => {
+                processing_frontier.set_source_state(crate::RawTransactionIngestSourceState::Failed);
+                std::result::Result::Err(source_transport_error(error.code()))
+            },
+        };
+    }
+}
+
+impl std::fmt::Debug for crate::RawTransactionIngestStandardLogsSource {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let http_snapshot = self.http_pool.snapshot();
+        return formatter
+            .debug_struct("RawTransactionIngestStandardLogsSource")
+            .field("ws_endpoint_name", &self.ws_endpoint.name())
+            .field("ws_provider", &self.ws_endpoint.provider().as_str())
+            .field("network", &self.network.as_str())
+            .field("commitment", &self.commitment)
+            .field("filter_kind", &standard_logs_filter_kind(&self.filter))
+            .field("filter_fingerprint_bytes", &self.filter_fingerprint.len())
+            .field("hydration_role", &self.hydration_role.as_str())
+            .field("http_endpoint_count", &http_snapshot.endpoint_count())
+            .field("source_key_bytes", &self.source_key.len())
+            .finish();
+    }
+}
+
 impl std::fmt::Debug for crate::RawTransactionIngestYellowstoneSource {
     fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let http_snapshot = self.http_pool.snapshot();
@@ -545,8 +848,8 @@ impl std::fmt::Debug for crate::RawTransactionIngestYellowstoneSource {
 
 /// Caller-composed runtime resources accepted by the continuous RAW transaction ingest Worker.
 ///
-/// The aggregate owns a bounded collection of capability-specific live-source contracts. `pre.002` validates composition and stable logical identities but
-/// deliberately keeps productive multi-source supervision gated until the dedicated supervisor tranche.
+/// The aggregate owns a bounded collection of capability-specific live-source contracts. `pre.003` supports Yellowstone and standard Solana logs sources while
+/// deliberately keeping simultaneous multi-source supervision gated until the dedicated supervisor tranche.
 pub struct RawTransactionIngestRuntimeResources {
     sources: std::vec::Vec<RawTransactionIngestLiveSource>,
 }
@@ -558,6 +861,12 @@ impl crate::RawTransactionIngestRuntimeResources {
         return Self { sources: std::vec![RawTransactionIngestLiveSource::Yellowstone(yellowstone_source)] };
     }
 
+    /// Creates one runtime-resource aggregate from one standard Solana `logsSubscribe` plus HTTP hydration source contract.
+    #[must_use]
+    pub fn from_standard_logs_source(source: crate::RawTransactionIngestStandardLogsSource) -> Self {
+        return Self { sources: std::vec![RawTransactionIngestLiveSource::StandardLogs(source)] };
+    }
+
     /// Returns the number of validated logical live sources currently owned by this aggregate.
     #[must_use]
     pub fn source_count(&self) -> usize {
@@ -585,6 +894,27 @@ impl crate::RawTransactionIngestRuntimeResources {
         return std::result::Result::Ok(());
     }
 
+    /// Adds one validated standard Solana logs source while preserving the global 1..32 bound, one-network invariant and unique logical source identity.
+    pub fn try_push_standard_logs_source(&mut self, source: crate::RawTransactionIngestStandardLogsSource) -> ksp_core_lib::Result<()> {
+        if self.sources.len() >= crate::MAX_RAW_TRANSACTION_INGEST_LIVE_SOURCES {
+            return std::result::Result::Err(crate::runtime_error("runtime_resources.source_count_exceeded"));
+        }
+        let candidate = RawTransactionIngestLiveSource::StandardLogs(source);
+        let expected_network = match self.sources.first() {
+            std::option::Option::Some(source) => source.network(),
+            std::option::Option::None => return std::result::Result::Err(crate::runtime_error("runtime_resources.source_collection_empty")),
+        };
+        if candidate.network() != expected_network {
+            return std::result::Result::Err(crate::runtime_error("runtime_resources.source_network_mismatch"));
+        }
+        let source_key = candidate.source_key();
+        if self.sources.iter().any(|source| return source.source_key() == source_key) {
+            return std::result::Result::Err(crate::runtime_error("runtime_resources.duplicate_source_identity"));
+        }
+        self.sources.push(candidate);
+        return std::result::Result::Ok(());
+    }
+
     /// Validates that caller-owned Worker settings target the same logical network as every composed live source.
     pub(crate) fn validate_network(&self, network: &ksp_store_lib::RawNetworkId) -> ksp_core_lib::Result<()> {
         if self.sources.is_empty() || self.sources.len() > crate::MAX_RAW_TRANSACTION_INGEST_LIVE_SOURCES {
@@ -602,22 +932,34 @@ impl crate::RawTransactionIngestRuntimeResources {
         return std::result::Result::Ok(());
     }
 
-    /// Consumes the aggregate into the single Yellowstone source supported by the current productive supervisor wiring.
-    ///
-    /// Multi-source activation is intentionally deferred to the dedicated supervisor/source-inventory tranche; a collection larger than one therefore fails
-    /// closed rather than silently dropping sources or starting only a subset.
-    pub(crate) fn into_yellowstone_source(self) -> ksp_core_lib::Result<crate::RawTransactionIngestYellowstoneSource> {
+    /// Validates that the current supervisor tranche can activate the aggregate without silently dropping configured sources.
+    pub(crate) fn validate_single_source_activation(&self) -> ksp_core_lib::Result<()> {
         if self.sources.is_empty() {
             return std::result::Result::Err(crate::runtime_error("runtime_resources.source_collection_empty"));
         }
         if self.sources.len() != 1 {
             return std::result::Result::Err(crate::runtime_error("runtime_resources.multi_source_activation_pending"));
         }
+        return std::result::Result::Ok(());
+    }
+
+    /// Runs the already validated single live source through the common Worker source-task contract.
+    pub(crate) async fn run_single_live_source(
+        self,
+        settings: crate::RawTransactionIngestSettings,
+        stop_receiver: tokio::sync::watch::Receiver<bool>,
+        admission_sender: tokio::sync::mpsc::Sender<crate::RawTransactionIngress>,
+        processing_frontier_sender: tokio::sync::watch::Sender<crate::RawTransactionIngestProcessingFrontierProjection>,
+    ) -> ksp_core_lib::Result<()> {
         let mut sources = self.sources.into_iter();
-        return match sources.next() {
-            std::option::Option::Some(RawTransactionIngestLiveSource::Yellowstone(source)) => std::result::Result::Ok(source),
-            std::option::Option::None => std::result::Result::Err(crate::runtime_error("runtime_resources.source_collection_empty")),
+        let source = match sources.next() {
+            std::option::Option::Some(value) => value,
+            std::option::Option::None => return std::result::Result::Err(crate::runtime_error("runtime_resources.source_collection_empty")),
         };
+        if sources.next().is_some() {
+            return std::result::Result::Err(crate::runtime_error("runtime_resources.multi_source_activation_pending"));
+        }
+        return source.run(settings, stop_receiver, admission_sender, processing_frontier_sender).await;
     }
 }
 
@@ -642,6 +984,45 @@ impl std::hash::Hasher for RawTransactionIngestSourceKeyHashWriter<'_> {
     }
 }
 
+fn standard_logs_filter_fingerprint(filter: &ksp_onchain_transport_lib::SolanaLogsSubscribeFilter) -> [u8; 32] {
+    let mut hasher = sha2::Sha256::new();
+    hasher.update(RAW_TRANSACTION_INGEST_STANDARD_LOGS_FILTER_FINGERPRINT_DOMAIN);
+    match filter {
+        ksp_onchain_transport_lib::SolanaLogsSubscribeFilter::All => hash_live_source_key_component(&mut hasher, b"all"),
+        ksp_onchain_transport_lib::SolanaLogsSubscribeFilter::AllWithVotes => hash_live_source_key_component(&mut hasher, b"allWithVotes"),
+        ksp_onchain_transport_lib::SolanaLogsSubscribeFilter::Mentions(pubkey) => {
+            hash_live_source_key_component(&mut hasher, b"mentions");
+            hash_live_source_key_component(&mut hasher, &pubkey.to_bytes());
+        },
+    }
+    return hasher.finalize().into();
+}
+
+fn standard_logs_filter_kind(filter: &ksp_onchain_transport_lib::SolanaLogsSubscribeFilter) -> &'static str {
+    return match filter {
+        ksp_onchain_transport_lib::SolanaLogsSubscribeFilter::All => "all",
+        ksp_onchain_transport_lib::SolanaLogsSubscribeFilter::AllWithVotes => "all_with_votes",
+        ksp_onchain_transport_lib::SolanaLogsSubscribeFilter::Mentions(_) => "mentions",
+    };
+}
+
+fn standard_logs_live_source_key(
+    network: &ksp_store_lib::RawNetworkId,
+    route: &RawTransactionIngestSourceRoute,
+    commitment: ksp_onchain_transport_lib::SolanaCommitment,
+    filter_fingerprint: &[u8; 32],
+) -> [u8; 32] {
+    let mut hasher = sha2::Sha256::new();
+    hasher.update(RAW_TRANSACTION_INGEST_LIVE_SOURCE_KEY_DOMAIN);
+    hash_live_source_key_component(&mut hasher, b"standard_logs");
+    hash_live_source_key_component(&mut hasher, network.as_str().as_bytes());
+    hash_live_source_key_component(&mut hasher, route.provider.as_str().as_bytes());
+    hash_live_source_key_component(&mut hasher, route.endpoint_id.as_str().as_bytes());
+    hash_live_source_key_component(&mut hasher, commitment.as_str().as_bytes());
+    hash_live_source_key_component(&mut hasher, filter_fingerprint);
+    return hasher.finalize().into();
+}
+
 fn yellowstone_live_source_key(
     network: &ksp_store_lib::RawNetworkId,
     route: &RawTransactionIngestSourceRoute,
@@ -675,7 +1056,8 @@ fn compatible_http_route_count(
     hydration_role: &ksp_onchain_transport_lib::HttpRoleName,
     request_kind: &str,
     expected_cluster: &str,
-    yellowstone_route: &RawTransactionIngestSourceRoute,
+    source_route: &RawTransactionIngestSourceRoute,
+    route_prefix: &str,
 ) -> ksp_core_lib::Result<usize> {
     let snapshot = pool.snapshot();
     let mut compatible = 0_usize;
@@ -694,7 +1076,7 @@ fn compatible_http_route_count(
             if endpoint.cluster() != expected_cluster {
                 return std::result::Result::Err(crate::runtime_error("runtime_resources.transport_network_mismatch"));
             }
-            let composite = composite_provenance_codes(yellowstone_route, endpoint.provider(), endpoint.name());
+            let composite = composite_provenance_codes(source_route, route_prefix, endpoint.provider(), endpoint.name());
             if let std::result::Result::Err(error) = composite {
                 return std::result::Result::Err(error);
             }
@@ -705,18 +1087,19 @@ fn compatible_http_route_count(
 }
 
 fn composite_provenance_codes(
-    yellowstone_route: &RawTransactionIngestSourceRoute,
+    source_route: &RawTransactionIngestSourceRoute,
+    route_prefix: &str,
     http_provider: &str,
     http_endpoint: &str,
 ) -> ksp_core_lib::Result<(ksp_store_lib::RawProvenanceCode, ksp_store_lib::RawProvenanceCode)> {
-    let provider = std::format!("ys.{}:http.{}", yellowstone_route.provider.as_str(), http_provider);
+    let provider = std::format!("{}.{}:http.{}", route_prefix, source_route.provider.as_str(), http_provider);
     let provider = match ksp_store_lib::RawProvenanceCode::new(provider) {
         std::result::Result::Ok(value) => value,
         std::result::Result::Err(_) => {
             return std::result::Result::Err(crate::runtime_error("runtime_resources.composite_provider_unrepresentable"));
         },
     };
-    let endpoint = std::format!("ys.{}:http.{}", yellowstone_route.endpoint_id.as_str(), http_endpoint);
+    let endpoint = std::format!("{}.{}:http.{}", route_prefix, source_route.endpoint_id.as_str(), http_endpoint);
     let endpoint = match ksp_store_lib::RawProvenanceCode::new(endpoint) {
         std::result::Result::Ok(value) => value,
         std::result::Result::Err(_) => {
@@ -849,8 +1232,48 @@ fn project_yellowstone_signal<T: RawTransactionIngestYellowstoneSignalView>(
     };
 }
 
+trait RawTransactionIngestStandardLogsView {
+    fn signature(&self) -> &str;
+
+    fn slot(&self) -> u64;
+}
+
+impl RawTransactionIngestStandardLogsView for ksp_onchain_transport_lib::SolanaRpcResponse<ksp_onchain_transport_lib::SolanaLogsNotification> {
+    fn signature(&self) -> &str {
+        return self.value().signature();
+    }
+
+    fn slot(&self) -> u64 {
+        return self.context().slot();
+    }
+}
+
+fn project_standard_logs_signal<T: RawTransactionIngestStandardLogsView>(
+    source: &crate::RawTransactionIngestStandardLogsSource,
+    response: &T,
+) -> ksp_core_lib::Result<RawTransactionIngestSourceSignal> {
+    let signature = ksp_raw_transaction_lib::parse_raw_transaction_signature(response.signature());
+    let signature = match signature {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(_) => return std::result::Result::Err(crate::runtime_error("source.standard_logs_signature_invalid")),
+    };
+    return std::result::Result::Ok(RawTransactionIngestSourceSignal {
+        created_at: std::option::Option::None,
+        family: RawTransactionIngestSourceFamily::Logs,
+        matched_filter_count: 1,
+        matched_filter_fingerprint: source.filter_fingerprint,
+        matched_filter_id: std::option::Option::None,
+        network: source.network.clone(),
+        route: source.route.clone(),
+        signature,
+        slot: response.slot(),
+        transaction_index: std::option::Option::None,
+    });
+}
+
 fn route_yellowstone_update(
     source: &crate::RawTransactionIngestYellowstoneSource,
+    hydration: &RawTransactionIngestHydrationContext,
     coordinator: &mut RawTransactionIngestHydrationCoordinator,
     processing_frontier: &mut RawTransactionIngestProcessingFrontierReporter,
     update: ksp_onchain_transport_lib::YellowstoneSubscribeUpdate,
@@ -861,14 +1284,14 @@ fn route_yellowstone_update(
                 std::result::Result::Ok(value) => value,
                 std::result::Result::Err(error) => return std::result::Result::Err(error),
             };
-            return coordinator.queue_signal(source, RawTransactionIngestSourceSignal::from((source, value.as_ref())), received_at, processing_frontier);
+            return coordinator.queue_signal(hydration, RawTransactionIngestSourceSignal::from((source, value.as_ref())), received_at, processing_frontier);
         },
         ksp_onchain_transport_lib::YellowstoneSubscribeUpdate::TransactionStatus(value) => {
             let received_at = match current_raw_timestamp() {
                 std::result::Result::Ok(value) => value,
                 std::result::Result::Err(error) => return std::result::Result::Err(error),
             };
-            return coordinator.queue_signal(source, RawTransactionIngestSourceSignal::from((source, &value)), received_at, processing_frontier);
+            return coordinator.queue_signal(hydration, RawTransactionIngestSourceSignal::from((source, &value)), received_at, processing_frontier);
         },
         ksp_onchain_transport_lib::YellowstoneSubscribeUpdate::Block(value) => {
             let received_at = match current_raw_timestamp() {
@@ -880,7 +1303,7 @@ fn route_yellowstone_update(
                 std::result::Result::Err(error) => return std::result::Result::Err(error),
             };
             for signal in signals {
-                if let std::result::Result::Err(error) = coordinator.queue_signal(source, signal, received_at, processing_frontier) {
+                if let std::result::Result::Err(error) = coordinator.queue_signal(hydration, signal, received_at, processing_frontier) {
                     return std::result::Result::Err(error);
                 }
             }
@@ -935,7 +1358,7 @@ async fn wait_yellowstone_session_snapshot(
 }
 
 fn source_transport_error(code: ksp_core_lib::ErrorCode) -> ksp_core_lib::Error {
-    return ksp_core_lib::Error::new(crate::ERROR_CODE_RAW_TRANSACTION_INGEST_SOURCE_FAILED, "RAW transaction ingest Yellowstone source transport failed")
+    return ksp_core_lib::Error::new(crate::ERROR_CODE_RAW_TRANSACTION_INGEST_SOURCE_FAILED, "RAW transaction ingest source transport failed")
         .with_context("transport_domain", code.domain())
         .with_context("transport_code", code.code());
 }
@@ -1251,7 +1674,7 @@ impl RawTransactionIngestHydrationCoordinator {
     fn new(settings: &crate::RawTransactionIngestSettings) -> Self {
         return Self {
             max_in_flight: settings.persistence_concurrency(),
-            max_pending_signals: crate::MAX_RAW_TRANSACTION_INGEST_ADMISSION_QUEUE_CAPACITY,
+            max_pending_signals: settings.admission_queue_capacity(),
             pending_signal_count: 0,
             pending: std::collections::BTreeMap::new(),
             tasks: RawTransactionIngestHydrationTasks::new(),
@@ -1264,7 +1687,7 @@ impl RawTransactionIngestHydrationCoordinator {
 
     fn queue_signal(
         &mut self,
-        source: &crate::RawTransactionIngestYellowstoneSource,
+        hydration: &RawTransactionIngestHydrationContext,
         signal: RawTransactionIngestSourceSignal,
         received_at: ksp_store_lib::RawTimestamp,
         processing_frontier: &mut RawTransactionIngestProcessingFrontierReporter,
@@ -1272,7 +1695,7 @@ impl RawTransactionIngestHydrationCoordinator {
         if self.pending_signal_count >= self.max_pending_signals {
             return std::result::Result::Err(crate::runtime_error("source.hydration_pending_saturated"));
         }
-        let key = match hydration_key(source, &signal) {
+        let key = match hydration_key(hydration, &signal) {
             std::result::Result::Ok(value) => value,
             std::result::Result::Err(error) => return std::result::Result::Err(error),
         };
@@ -1295,10 +1718,10 @@ impl RawTransactionIngestHydrationCoordinator {
         if let std::result::Result::Err(error) = processing_frontier.observe_pending(signal_slot) {
             return std::result::Result::Err(error);
         }
-        return self.start_hydrations(source);
+        return self.start_hydrations(hydration);
     }
 
-    fn start_hydrations(&mut self, source: &crate::RawTransactionIngestYellowstoneSource) -> ksp_core_lib::Result<()> {
+    fn start_hydrations(&mut self, hydration: &RawTransactionIngestHydrationContext) -> ksp_core_lib::Result<()> {
         while self.tasks.len() < self.max_in_flight {
             let key = self.pending.iter().find_map(|(key, pending)| {
                 if pending.in_flight {
@@ -1310,21 +1733,18 @@ impl RawTransactionIngestHydrationCoordinator {
                 std::option::Option::Some(value) => value,
                 std::option::Option::None => break,
             };
-            let commitment = match hydration_commitment(source) {
-                std::result::Result::Ok(value) => value,
-                std::result::Result::Err(error) => return std::result::Result::Err(error),
-            };
+            let commitment = hydration.commitment;
             let pending = match self.pending.get_mut(&key) {
                 std::option::Option::Some(value) => value,
                 std::option::Option::None => return std::result::Result::Err(crate::runtime_error("source.hydration_pending_missing")),
             };
             pending.in_flight = true;
-            let pool = source.http_pool.clone();
-            let role = source.hydration_role.clone();
-            let expected_network = source.network.clone();
+            let pool = hydration.http_pool.clone();
+            let role = hydration.hydration_role.clone();
+            let expected_network = hydration.network.clone();
             let task_key = key.clone();
             let _abort_handle = self.tasks.spawn(async move {
-                return fetch_yellowstone_hydration(pool, role, expected_network, task_key, commitment).await;
+                return fetch_hydration(pool, role, expected_network, task_key, commitment).await;
             });
         }
         return std::result::Result::Ok(());
@@ -1333,7 +1753,7 @@ impl RawTransactionIngestHydrationCoordinator {
     async fn handle_joined(
         &mut self,
         joined: std::result::Result<ksp_core_lib::Result<RawTransactionIngestHydrationFetch>, tokio::task::JoinError>,
-        source: &crate::RawTransactionIngestYellowstoneSource,
+        hydration: &RawTransactionIngestHydrationContext,
         settings: &crate::RawTransactionIngestSettings,
         admission_sender: &tokio::sync::mpsc::Sender<crate::RawTransactionIngress>,
         stop_receiver: &mut tokio::sync::watch::Receiver<bool>,
@@ -1354,7 +1774,7 @@ impl RawTransactionIngestHydrationCoordinator {
         self.pending_signal_count -= pending.signals.len();
         for pending_signal in pending.signals {
             let signal_slot = pending_signal.signal.slot;
-            let ingress = finalize_yellowstone_hydration(source, settings, pending_signal.signal, pending_signal.received_at, &fetched.observed);
+            let ingress = finalize_hydration(hydration, settings, pending_signal.signal, pending_signal.received_at, &fetched.observed);
             let ingress = match ingress {
                 std::result::Result::Ok(value) => value,
                 std::result::Result::Err(error) => return std::result::Result::Err(error),
@@ -1385,7 +1805,7 @@ impl RawTransactionIngestHydrationCoordinator {
                 return std::result::Result::Err(error);
             }
         }
-        if let std::result::Result::Err(error) = self.start_hydrations(source) {
+        if let std::result::Result::Err(error) = self.start_hydrations(hydration) {
             return std::result::Result::Err(error);
         }
         return std::result::Result::Ok(true);
@@ -1401,39 +1821,21 @@ impl RawTransactionIngestHydrationCoordinator {
     }
 }
 
-fn hydration_commitment(source: &crate::RawTransactionIngestYellowstoneSource) -> ksp_core_lib::Result<ksp_onchain_transport_lib::SolanaCommitment> {
-    return match source.subscribe_request.commitment() {
-        std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Confirmed) => {
-            std::result::Result::Ok(ksp_onchain_transport_lib::SolanaCommitment::Confirmed)
-        },
-        std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Finalized) => {
-            std::result::Result::Ok(ksp_onchain_transport_lib::SolanaCommitment::Finalized)
-        },
-        std::option::Option::Some(ksp_onchain_transport_lib::SolanaCommitment::Processed) | std::option::Option::None => {
-            std::result::Result::Err(crate::runtime_error("hydration.commitment_invalid"))
-        },
-    };
-}
-
 fn hydration_key(
-    source: &crate::RawTransactionIngestYellowstoneSource,
+    hydration: &RawTransactionIngestHydrationContext,
     signal: &RawTransactionIngestSourceSignal,
 ) -> ksp_core_lib::Result<RawTransactionIngestHydrationKey> {
-    if signal.network != source.network {
+    if signal.network != hydration.network {
         return std::result::Result::Err(crate::runtime_error("hydration.network_mismatch"));
     }
-    let commitment = match hydration_commitment(source) {
-        std::result::Result::Ok(value) => value,
-        std::result::Result::Err(error) => return std::result::Result::Err(error),
-    };
     return std::result::Result::Ok(RawTransactionIngestHydrationKey {
-        commitment: commitment.as_str(),
+        commitment: hydration.commitment.as_str(),
         network: signal.network.clone(),
         signature: signal.signature,
     });
 }
 
-async fn fetch_yellowstone_hydration(
+async fn fetch_hydration(
     http_pool: ksp_onchain_transport_lib::HttpTransportPool,
     hydration_role: ksp_onchain_transport_lib::HttpRoleName,
     expected_network: ksp_store_lib::RawNetworkId,
@@ -1449,7 +1851,7 @@ async fn fetch_yellowstone_hydration(
     let config = ksp_onchain_transport_lib::SolanaGetTransactionConfig::new(
         std::option::Option::Some(commitment),
         std::option::Option::Some(ksp_onchain_transport_lib::SolanaTransactionEncoding::Base64),
-        std::option::Option::Some(0),
+        std::option::Option::Some(1),
     );
     let signature_text = ksp_raw_transaction_lib::format_raw_transaction_signature(&key.signature);
     let observed = http_pool.get_transaction_observed(&hydration_role, signature_text.as_str(), std::option::Option::Some(&config)).await;
@@ -1460,23 +1862,20 @@ async fn fetch_yellowstone_hydration(
     return std::result::Result::Ok(RawTransactionIngestHydrationFetch { key, observed });
 }
 
-fn finalize_yellowstone_hydration(
-    source: &crate::RawTransactionIngestYellowstoneSource,
+fn finalize_hydration(
+    hydration: &RawTransactionIngestHydrationContext,
     settings: &crate::RawTransactionIngestSettings,
     signal: RawTransactionIngestSourceSignal,
     received_at: ksp_store_lib::RawTimestamp,
     observed: &RawTransactionIngestObservedTransaction,
 ) -> ksp_core_lib::Result<std::option::Option<crate::RawTransactionIngress>> {
-    if &signal.network != settings.network() || signal.network != source.network {
+    if &signal.network != settings.network() || signal.network != hydration.network {
         return std::result::Result::Err(crate::runtime_error("hydration.network_mismatch"));
     }
-    if signal.route != source.route {
+    if signal.route != hydration.route {
         return std::result::Result::Err(crate::runtime_error("hydration.source_route_mismatch"));
     }
-    let commitment = match hydration_commitment(source) {
-        std::result::Result::Ok(value) => value,
-        std::result::Result::Err(error) => return std::result::Result::Err(error),
-    };
+    let commitment = hydration.commitment;
     let transaction = match observed.value().as_ref() {
         std::option::Option::Some(value) => value,
         std::option::Option::None => return std::result::Result::Ok(std::option::Option::None),
@@ -1510,12 +1909,12 @@ fn finalize_yellowstone_hydration(
     if embedded_signature != signal.signature {
         return std::result::Result::Err(crate::runtime_error("hydration.signature_mismatch"));
     }
-    let provenance = build_hydration_provenance(settings, &signal, observed.provider().as_str(), observed.endpoint_name(), commitment, received_at);
+    let provenance = build_hydration_provenance(hydration, settings, &signal, observed.provider().as_str(), observed.endpoint_name(), commitment, received_at);
     let provenance = match provenance {
         std::result::Result::Ok(value) => value,
         std::result::Result::Err(error) => return std::result::Result::Err(error),
     };
-    let source_key = hydration_source_key(&provenance);
+    let source_key = hydration_source_key(hydration.source_key_domain, &provenance);
     let material = ksp_raw_transaction_lib::RawTransactionMaterial::binary_base64(
         signal.network.clone(),
         signal.signature,
@@ -1548,20 +1947,18 @@ async fn hydrate_yellowstone_signal(
     received_at: ksp_store_lib::RawTimestamp,
 ) -> ksp_core_lib::Result<RawTransactionIngestHydrationOutcome> {
     let reference = ksp_store_lib::RawTransactionReference::new(signal.network.clone(), signal.signature);
-    let key = match hydration_key(source, &signal) {
+    let hydration = source.hydration_context();
+    let key = match hydration_key(&hydration, &signal) {
         std::result::Result::Ok(value) => value,
         std::result::Result::Err(error) => return std::result::Result::Err(error),
     };
-    let commitment = match hydration_commitment(source) {
-        std::result::Result::Ok(value) => value,
-        std::result::Result::Err(error) => return std::result::Result::Err(error),
-    };
-    let fetched = fetch_yellowstone_hydration(source.http_pool.clone(), source.hydration_role.clone(), source.network.clone(), key, commitment).await;
+    let commitment = hydration.commitment;
+    let fetched = fetch_hydration(hydration.http_pool.clone(), hydration.hydration_role.clone(), hydration.network.clone(), key, commitment).await;
     let fetched = match fetched {
         std::result::Result::Ok(value) => value,
         std::result::Result::Err(error) => return std::result::Result::Err(error),
     };
-    let ingress = finalize_yellowstone_hydration(source, settings, signal, received_at, &fetched.observed);
+    let ingress = finalize_hydration(&hydration, settings, signal, received_at, &fetched.observed);
     return match ingress {
         std::result::Result::Ok(std::option::Option::Some(value)) => {
             std::result::Result::Ok(RawTransactionIngestHydrationOutcome::Available(std::boxed::Box::new(value)))
@@ -1572,6 +1969,7 @@ async fn hydrate_yellowstone_signal(
 }
 
 fn build_hydration_provenance(
+    hydration: &RawTransactionIngestHydrationContext,
     settings: &crate::RawTransactionIngestSettings,
     signal: &RawTransactionIngestSourceSignal,
     http_provider: &str,
@@ -1579,11 +1977,11 @@ fn build_hydration_provenance(
     commitment: ksp_onchain_transport_lib::SolanaCommitment,
     received_at: ksp_store_lib::RawTimestamp,
 ) -> ksp_core_lib::Result<ksp_store_lib::RawAcquisitionProvenance> {
-    let (provider, endpoint_id) = match composite_provenance_codes(&signal.route, http_provider, http_endpoint) {
+    let (provider, endpoint_id) = match composite_provenance_codes(&signal.route, hydration.route_prefix, http_provider, http_endpoint) {
         std::result::Result::Ok(value) => value,
         std::result::Result::Err(error) => return std::result::Result::Err(error),
     };
-    let protocol = match ksp_store_lib::RawProvenanceCode::new(RAW_TRANSACTION_INGEST_YELLOWSTONE_HTTP_PROTOCOL) {
+    let protocol = match ksp_store_lib::RawProvenanceCode::new(hydration.protocol) {
         std::result::Result::Ok(value) => value,
         std::result::Result::Err(_) => return std::result::Result::Err(crate::runtime_error("hydration.protocol_unrepresentable")),
     };
@@ -1624,6 +2022,7 @@ fn build_hydration_provenance(
 fn hydration_method_code(family: RawTransactionIngestSourceFamily) -> &'static str {
     return match family {
         RawTransactionIngestSourceFamily::Block => "block_get_transaction",
+        RawTransactionIngestSourceFamily::Logs => "logs_get_transaction",
         RawTransactionIngestSourceFamily::Transaction => "transaction_get_transaction",
         RawTransactionIngestSourceFamily::TransactionStatus => "status_get_transaction",
     };
@@ -1669,9 +2068,9 @@ fn representable_observed_at(
     return std::option::Option::Some(observed_at);
 }
 
-fn hydration_source_key(provenance: &ksp_store_lib::RawAcquisitionProvenance) -> [u8; 32] {
+fn hydration_source_key(source_key_domain: &[u8], provenance: &ksp_store_lib::RawAcquisitionProvenance) -> [u8; 32] {
     let mut hasher = sha2::Sha256::new();
-    hasher.update(RAW_TRANSACTION_INGEST_YELLOWSTONE_HTTP_SOURCE_KEY_DOMAIN);
+    hasher.update(source_key_domain);
     hash_hydration_source_key(&mut hasher, provenance.provider().as_str().as_bytes());
     hash_hydration_source_key(&mut hasher, provenance.protocol().as_str().as_bytes());
     hash_hydration_source_key(&mut hasher, provenance.acquisition_method().as_str().as_bytes());