v0.1.0-pre.013

kb-lib/src/lib.rs

@@ -1,5 +1,5 @@
 // file: kb-lib/src/lib.rs
-// version: 15
+// version: 16
 
 //! Consolidated decoder, executor, materializer and shared model library.
 #![warn(missing_docs)]
@@ -869,24 +869,52 @@ pub use self::materializer::MtApiMaterializerExecutionResult;
 pub use self::materializer::MtApiMaterializerIdentity;
 /// Terminal materializer result status.
 pub use self::materializer::MtApiMaterializerOutcomeStatus;
+/// Reserved bridge materializer.
+pub use self::materializer::MtBridgeMaterializer;
 /// Stable native compliance audit materializer.
 pub use self::materializer::MtComplianceAuditMaterializer;
 /// Fee materializer for committed Token-2022 fee observations.
 pub use self::materializer::MtFeesMaterializer;
+/// Reserved governance materializer.
+pub use self::materializer::MtGovernanceMaterializer;
+/// Reserved lending materializer.
+pub use self::materializer::MtLendingMaterializer;
 /// Stable native lifecycle materializer.
 pub use self::materializer::MtLifecycleMaterializer;
+/// Reserved liquidity materializer.
+pub use self::materializer::MtLiquidityMaterializer;
 /// Exposes the legacy common business materializer trait.
 pub use self::materializer::MtMaterializer;
 /// Token-2022 and Metaplex metadata snapshot materializer.
 pub use self::materializer::MtMetadataMaterializer;
+/// Reserved NFT materializer.
+pub use self::materializer::MtNftMaterializer;
+/// Reserved oracle materializer.
+pub use self::materializer::MtOracleMaterializer;
+/// Reserved orderbook materializer.
+pub use self::materializer::MtOrderbookMaterializer;
+/// Reserved perpetuals materializer.
+pub use self::materializer::MtPerpetualsMaterializer;
+/// Reserved pool-state materializer.
+pub use self::materializer::MtPoolStateMaterializer;
+/// Reserved rewards materializer.
+pub use self::materializer::MtRewardsMaterializer;
 /// Stable SPL Token and ATA risk materializer.
 pub use self::materializer::MtRiskMaterializer;
+/// Reserved routing materializer.
+pub use self::materializer::MtRoutingMaterializer;
 /// Stable native stake and vote materializer.
 pub use self::materializer::MtStakingMaterializer;
 /// Stable Token, ATA and Token-2022 account materializer.
 pub use self::materializer::MtTokenAccountsMaterializer;
+/// Reserved token-metadata risk materializer.
+pub use self::materializer::MtTokenMetadataRiskMaterializer;
+/// Reserved trades materializer.
+pub use self::materializer::MtTradesMaterializer;
 /// Stable committed Memo transaction annotation materializer.
 pub use self::materializer::MtTransactionAnnotationMaterializer;
+/// Reserved vault materializer.
+pub use self::materializer::MtVaultMaterializer;
 /// Materializes one exact SPL ElGamal registry account snapshot.
 pub use self::materializer::materializer_admin_materialize_elgamal_registry_state_snapshot;
 /// Materializes exact Token-2022 administration account snapshots.

kb-lib/src/materializer.rs

@@ -1,5 +1,5 @@
 // file: kb-lib/src/materializer.rs
-// version: 4
+// version: 5
 
 //! Consolidated materializer modules.
 
@@ -27,6 +27,91 @@ mod trades;
 mod transaction;
 mod vault;
 
+/// Stable native and SPL administration materializer.
+pub use self::admin::MtAdminMaterializer;
+/// Materializes one exact SPL ElGamal registry account snapshot.
+pub use self::admin::materializer_admin_materialize_elgamal_registry_state_snapshot;
+/// Materializes exact Token-2022 administration account snapshots.
+pub use self::admin::materializer_admin_materialize_token2022_state_snapshots;
+/// Stable decoded observation materializer contract used by the common pipeline.
+pub use self::api::MtApiEventMaterializer;
+/// Explicit policy applied to successful and failed source transactions.
+pub use self::api::MtApiMaterializationTransactionPolicy;
+/// Stable processor-owned business output derived from one decoded observation.
+pub use self::api::MtApiMaterializedOutput;
+/// Structured materializer diagnostic without generic error wrappers.
+pub use self::api::MtApiMaterializerDiagnostic;
+/// Complete explicit result produced by one materializer invocation.
+pub use self::api::MtApiMaterializerExecutionResult;
+/// Stable identity of one decoded event materializer.
+pub use self::api::MtApiMaterializerIdentity;
+/// Terminal materializer result status.
+pub use self::api::MtApiMaterializerOutcomeStatus;
+/// Exposes the legacy common business materializer trait.
+pub use self::api::MtMaterializer;
+/// Returns true when a materializer explicitly accepts one decoded family.
+pub use self::api::materializer_api_accepts_family;
+/// Returns true when a materializer accepts one exact decoded observation.
+pub use self::api::materializer_api_accepts_observation;
+/// Applies the mandatory source transaction policy before materialization.
+pub use self::api::materializer_api_validate_materialization_policy;
+/// Rejects mutable business outputs derived from failed or uncommitted observations.
+pub use self::api::materializer_api_validate_materialized_output_policy;
+/// Reserved bridge materializer.
+pub use self::bridge::MtBridgeMaterializer;
+/// Stable native compliance audit materializer.
+pub use self::compliance::MtComplianceAuditMaterializer;
+/// Fee materializer for committed Token-2022 fee observations.
+pub use self::fees::MtFeesMaterializer;
+/// Materializes authoritative Token-2022 fee extension snapshots.
+pub use self::fees::materializer_fees_materialize_token2022_state_snapshots;
+/// Reserved governance materializer.
+pub use self::governance::MtGovernanceMaterializer;
+/// Reserved lending materializer.
+pub use self::lending::MtLendingMaterializer;
+/// Stable native lifecycle materializer.
+pub use self::lifecycle::MtLifecycleMaterializer;
+/// Reserved liquidity materializer.
+pub use self::liquidity::MtLiquidityMaterializer;
+/// Token-2022 and Metaplex metadata snapshot materializer.
+pub use self::metadata::MtMetadataMaterializer;
+/// Materializes one canonical non-Metadata Metaplex account snapshot.
+pub use self::metadata::materializer_metadata_materialize_metaplex_account_snapshot;
+/// Materializes one canonical Metaplex Metadata account snapshot.
+pub use self::metadata::materializer_metadata_materialize_metaplex_metadata_snapshot;
+/// Materializes Token-2022 embedded metadata and group snapshots.
+pub use self::metadata::materializer_metadata_materialize_token2022_snapshot;
+/// Reserved NFT materializer.
+pub use self::nft::MtNftMaterializer;
+/// Reserved oracle materializer.
+pub use self::oracle::MtOracleMaterializer;
+/// Reserved orderbook materializer.
+pub use self::orderbook::MtOrderbookMaterializer;
+/// Reserved perpetuals materializer.
+pub use self::perpetuals::MtPerpetualsMaterializer;
+/// Reserved pool-state materializer.
+pub use self::pool::MtPoolStateMaterializer;
+/// Reserved rewards materializer.
+pub use self::rewards::MtRewardsMaterializer;
+/// Stable SPL Token and ATA risk materializer.
+pub use self::risk::MtRiskMaterializer;
+/// Reserved routing materializer.
+pub use self::routing::MtRoutingMaterializer;
+/// Stable native stake and vote materializer.
+pub use self::staking::MtStakingMaterializer;
+/// Stable Token, ATA and Token-2022 account materializer.
+pub use self::token::MtTokenAccountsMaterializer;
+/// Reserved token-metadata risk materializer.
+pub use self::token::MtTokenMetadataRiskMaterializer;
+/// Materializes one bounded Token-2022 account state snapshot.
+pub use self::token::materializer_token_materialize_token2022_state_snapshot;
+/// Reserved trades materializer.
+pub use self::trades::MtTradesMaterializer;
+/// Stable committed Memo transaction annotation materializer.
+pub use self::transaction::MtTransactionAnnotationMaterializer;
+/// Reserved vault materializer.
+pub use self::vault::MtVaultMaterializer;
+
 /// Canonical processor name for the native and SPL administration materializer.
 pub(crate) use self::admin::MT_ADMIN_PROCESSOR_NAME;
 /// Canonical tracing target for the native and SPL administration materializer.
@@ -58,59 +143,55 @@ pub(crate) use self::transaction::MT_TRANSACTION_ANNOTATIONS_PROJECTION_VERSION;
 /// Canonical tracing target for transaction annotations.
 pub(crate) use self::transaction::MT_TRANSACTION_ANNOTATIONS_TRACING_TARGET;
 
-/// Stable native and SPL administration materializer.
-pub use self::admin::MtAdminMaterializer;
-/// Materializes one exact SPL ElGamal registry account snapshot.
-pub use self::admin::materializer_admin_materialize_elgamal_registry_state_snapshot;
-/// Materializes exact Token-2022 administration account snapshots.
-pub use self::admin::materializer_admin_materialize_token2022_state_snapshots;
-/// Stable decoded observation materializer contract used by the common pipeline.
-pub use self::api::MtApiEventMaterializer;
-/// Explicit policy applied to successful and failed source transactions.
-pub use self::api::MtApiMaterializationTransactionPolicy;
-/// Stable processor-owned business output derived from one decoded observation.
-pub use self::api::MtApiMaterializedOutput;
-/// Structured materializer diagnostic without generic error wrappers.
-pub use self::api::MtApiMaterializerDiagnostic;
-/// Complete explicit result produced by one materializer invocation.
-pub use self::api::MtApiMaterializerExecutionResult;
-/// Stable identity of one decoded event materializer.
-pub use self::api::MtApiMaterializerIdentity;
-/// Terminal materializer result status.
-pub use self::api::MtApiMaterializerOutcomeStatus;
-/// Exposes the legacy common business materializer trait.
-pub use self::api::MtMaterializer;
-/// Returns true when a materializer explicitly accepts one decoded family.
-pub use self::api::materializer_api_accepts_family;
-/// Returns true when a materializer accepts one exact decoded observation.
-pub use self::api::materializer_api_accepts_observation;
-/// Applies the mandatory source transaction policy before materialization.
-pub use self::api::materializer_api_validate_materialization_policy;
-/// Rejects mutable business outputs derived from failed or uncommitted observations.
-pub use self::api::materializer_api_validate_materialized_output_policy;
-/// Stable native compliance audit materializer.
-pub use self::compliance::MtComplianceAuditMaterializer;
-/// Fee materializer for committed Token-2022 fee observations.
-pub use self::fees::MtFeesMaterializer;
-/// Materializes authoritative Token-2022 fee extension snapshots.
-pub use self::fees::materializer_fees_materialize_token2022_state_snapshots;
-/// Stable native lifecycle materializer.
-pub use self::lifecycle::MtLifecycleMaterializer;
-/// Token-2022 and Metaplex metadata snapshot materializer.
-pub use self::metadata::MtMetadataMaterializer;
-/// Materializes one canonical non-Metadata Metaplex account snapshot.
-pub use self::metadata::materializer_metadata_materialize_metaplex_account_snapshot;
-/// Materializes one canonical Metaplex Metadata account snapshot.
-pub use self::metadata::materializer_metadata_materialize_metaplex_metadata_snapshot;
-/// Materializes Token-2022 embedded metadata and group snapshots.
-pub use self::metadata::materializer_metadata_materialize_token2022_snapshot;
-/// Stable SPL Token and ATA risk materializer.
-pub use self::risk::MtRiskMaterializer;
-/// Stable native stake and vote materializer.
-pub use self::staking::MtStakingMaterializer;
-/// Stable Token, ATA and Token-2022 account materializer.
-pub use self::token::MtTokenAccountsMaterializer;
-/// Materializes one bounded Token-2022 account state snapshot.
-pub use self::token::materializer_token_materialize_token2022_state_snapshot;
-/// Stable committed Memo transaction annotation materializer.
-pub use self::transaction::MtTransactionAnnotationMaterializer;
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn reserved_materializers_expose_inactive_public_contracts() {
+        let materializers: &[(&dyn crate::MtApiEventMaterializer, &str)] = &[
+            (&crate::MtBridgeMaterializer, "kb_materializer_bridge"),
+            (&crate::MtGovernanceMaterializer, "kb_materializer_governance"),
+            (&crate::MtLendingMaterializer, "kb_materializer_lending"),
+            (&crate::MtLiquidityMaterializer, "kb_materializer_liquidity"),
+            (&crate::MtNftMaterializer, "kb_materializer_nft"),
+            (&crate::MtOracleMaterializer, "kb_materializer_oracle"),
+            (&crate::MtOrderbookMaterializer, "kb_materializer_orderbook"),
+            (&crate::MtPerpetualsMaterializer, "kb_materializer_perpetuals"),
+            (&crate::MtPoolStateMaterializer, "kb_materializer_pool_state"),
+            (&crate::MtRewardsMaterializer, "kb_materializer_rewards"),
+            (&crate::MtRoutingMaterializer, "kb_materializer_routing"),
+            (&crate::MtTokenMetadataRiskMaterializer, "kb_materializer_token_metadata_risk"),
+            (&crate::MtTradesMaterializer, "kb_materializer_trades"),
+            (&crate::MtVaultMaterializer, "kb_materializer_vault"),
+        ];
+        for (materializer, expected_name) in materializers {
+            let identity = materializer.identity();
+            assert_eq!(identity.name, *expected_name);
+            assert!(!identity.version.is_empty());
+            assert!(materializer.accepted_families().is_empty());
+        }
+    }
+
+    #[test]
+    fn reserved_materializers_preserve_legacy_trait_contracts() {
+        let materializers: &[(&dyn crate::MtMaterializer, &str)] = &[
+            (&crate::MtBridgeMaterializer, "kb_materializer_bridge"),
+            (&crate::MtGovernanceMaterializer, "kb_materializer_governance"),
+            (&crate::MtLendingMaterializer, "kb_materializer_lending"),
+            (&crate::MtLiquidityMaterializer, "kb_materializer_liquidity"),
+            (&crate::MtNftMaterializer, "kb_materializer_nft"),
+            (&crate::MtOracleMaterializer, "kb_materializer_oracle"),
+            (&crate::MtOrderbookMaterializer, "kb_materializer_orderbook"),
+            (&crate::MtPerpetualsMaterializer, "kb_materializer_perpetuals"),
+            (&crate::MtPoolStateMaterializer, "kb_materializer_pool_state"),
+            (&crate::MtRewardsMaterializer, "kb_materializer_rewards"),
+            (&crate::MtRoutingMaterializer, "kb_materializer_routing"),
+            (&crate::MtTokenMetadataRiskMaterializer, "kb_materializer_token_metadata_risk"),
+            (&crate::MtTradesMaterializer, "kb_materializer_trades"),
+            (&crate::MtVaultMaterializer, "kb_materializer_vault"),
+        ];
+        for (materializer, expected_name) in materializers {
+            assert_eq!(materializer.materializer_name(), *expected_name);
+            assert!(!materializer.materializer_version().is_empty());
+        }
+    }
+}

kb-lib/src/materializer/bridge.rs

@@ -1,6 +1,9 @@
 // file: kb-lib/src/materializer/bridge.rs
-// version: 2
+// version: 3
 
 //! `bridge` materializer family.
 
 mod core;
+
+/// Reserved bridge materializer.
+pub use self::core::MtBridgeMaterializer;

kb-lib/src/materializer/bridge/core.rs

@@ -1,9 +1,61 @@
 // file: kb-lib/src/materializer/bridge/core.rs
-// version: 2
+// version: 3
 
-//! Migration boundary for legacy crate `kb_materializer_bridge`.
+//! Reserved bridge materializer.
 
-/// Legacy crate name retained for migration and compatibility tracking.
-const LEGACY_CRATE: &str = "kb_materializer_bridge";
-/// Current porting status.
-const MIGRATION_STATUS: &str = "source-preserved-pending-port";
+/// Reserved materializer for bridge observations.
+#[derive(Clone, Debug, Default)]
+pub struct MtBridgeMaterializer;
+
+impl crate::MtMaterializer for crate::MtBridgeMaterializer {
+    fn materializer_name(&self) -> &'static str {
+        return "kb_materializer_bridge";
+    }
+
+    fn materializer_version(&self) -> &'static str {
+        return env!("CARGO_PKG_VERSION");
+    }
+
+    fn accepts_event(&self, _event: &crate::MdDecodedProtocolEvent) -> bool {
+        return false;
+    }
+
+    fn materialize_event(
+        &self,
+        event: &crate::MdDecodedProtocolEvent,
+    ) -> kb_core::Result<std::vec::Vec<crate::MdMaterializedEvent>> {
+        return std::result::Result::Ok(std::vec![crate::MdMaterializedEvent {
+            signature: event.signature.clone(),
+            slot: event.slot,
+            decoded_family: event.event_family,
+            materialized_family: crate::MdMaterializedEventFamily::Bridge,
+        }]);
+    }
+}
+
+impl crate::MtApiEventMaterializer for crate::MtBridgeMaterializer {
+    fn identity(&self) -> crate::MtApiMaterializerIdentity {
+        return crate::MtApiMaterializerIdentity {
+            name: "kb_materializer_bridge".to_string(),
+            version: env!("CARGO_PKG_VERSION").to_string(),
+        };
+    }
+
+    fn accepted_families(&self) -> &'static [crate::MdEventFamily] {
+        return &[];
+    }
+
+    fn transaction_policy(
+        &self,
+        _family: crate::MdEventFamily,
+    ) -> crate::MtApiMaterializationTransactionPolicy {
+        return crate::MtApiMaterializationTransactionPolicy::SuccessfulCommittedOnly;
+    }
+
+    fn materialize(
+        &self,
+        _observation: &crate::DcApiDecodedObservation,
+    ) -> crate::MtApiMaterializerExecutionResult {
+        return crate::MtApiMaterializerExecutionResult::ignored();
+    }
+}

kb-lib/src/materializer/governance.rs

@@ -1,6 +1,9 @@
 // file: kb-lib/src/materializer/governance.rs
-// version: 2
+// version: 3
 
 //! `governance` materializer family.
 
 mod core;
+
+/// Reserved governance materializer.
+pub use self::core::MtGovernanceMaterializer;

kb-lib/src/materializer/governance/core.rs

@@ -1,9 +1,61 @@
 // file: kb-lib/src/materializer/governance/core.rs
-// version: 2
+// version: 3
 
-//! Migration boundary for legacy crate `kb_materializer_governance`.
+//! Reserved governance materializer.
 
-/// Legacy crate name retained for migration and compatibility tracking.
-const LEGACY_CRATE: &str = "kb_materializer_governance";
-/// Current porting status.
-const MIGRATION_STATUS: &str = "source-preserved-pending-port";
+/// Reserved materializer for governance observations.
+#[derive(Clone, Debug, Default)]
+pub struct MtGovernanceMaterializer;
+
+impl crate::MtMaterializer for crate::MtGovernanceMaterializer {
+    fn materializer_name(&self) -> &'static str {
+        return "kb_materializer_governance";
+    }
+
+    fn materializer_version(&self) -> &'static str {
+        return env!("CARGO_PKG_VERSION");
+    }
+
+    fn accepts_event(&self, _event: &crate::MdDecodedProtocolEvent) -> bool {
+        return false;
+    }
+
+    fn materialize_event(
+        &self,
+        event: &crate::MdDecodedProtocolEvent,
+    ) -> kb_core::Result<std::vec::Vec<crate::MdMaterializedEvent>> {
+        return std::result::Result::Ok(std::vec![crate::MdMaterializedEvent {
+            signature: event.signature.clone(),
+            slot: event.slot,
+            decoded_family: event.event_family,
+            materialized_family: crate::MdMaterializedEventFamily::Governance,
+        }]);
+    }
+}
+
+impl crate::MtApiEventMaterializer for crate::MtGovernanceMaterializer {
+    fn identity(&self) -> crate::MtApiMaterializerIdentity {
+        return crate::MtApiMaterializerIdentity {
+            name: "kb_materializer_governance".to_string(),
+            version: env!("CARGO_PKG_VERSION").to_string(),
+        };
+    }
+
+    fn accepted_families(&self) -> &'static [crate::MdEventFamily] {
+        return &[];
+    }
+
+    fn transaction_policy(
+        &self,
+        _family: crate::MdEventFamily,
+    ) -> crate::MtApiMaterializationTransactionPolicy {
+        return crate::MtApiMaterializationTransactionPolicy::SuccessfulCommittedOnly;
+    }
+
+    fn materialize(
+        &self,
+        _observation: &crate::DcApiDecodedObservation,
+    ) -> crate::MtApiMaterializerExecutionResult {
+        return crate::MtApiMaterializerExecutionResult::ignored();
+    }
+}

kb-lib/src/materializer/lending.rs

@@ -1,6 +1,9 @@
 // file: kb-lib/src/materializer/lending.rs
-// version: 2
+// version: 3
 
 //! `lending` materializer family.
 
 mod core;
+
+/// Reserved lending materializer.
+pub use self::core::MtLendingMaterializer;

kb-lib/src/materializer/lending/core.rs

@@ -1,9 +1,61 @@
 // file: kb-lib/src/materializer/lending/core.rs
-// version: 2
+// version: 3
 
-//! Migration boundary for legacy crate `kb_materializer_lending`.
+//! Reserved lending materializer.
 
-/// Legacy crate name retained for migration and compatibility tracking.
-const LEGACY_CRATE: &str = "kb_materializer_lending";
-/// Current porting status.
-const MIGRATION_STATUS: &str = "source-preserved-pending-port";
+/// Reserved materializer for lending observations.
+#[derive(Clone, Debug, Default)]
+pub struct MtLendingMaterializer;
+
+impl crate::MtMaterializer for crate::MtLendingMaterializer {
+    fn materializer_name(&self) -> &'static str {
+        return "kb_materializer_lending";
+    }
+
+    fn materializer_version(&self) -> &'static str {
+        return env!("CARGO_PKG_VERSION");
+    }
+
+    fn accepts_event(&self, _event: &crate::MdDecodedProtocolEvent) -> bool {
+        return false;
+    }
+
+    fn materialize_event(
+        &self,
+        event: &crate::MdDecodedProtocolEvent,
+    ) -> kb_core::Result<std::vec::Vec<crate::MdMaterializedEvent>> {
+        return std::result::Result::Ok(std::vec![crate::MdMaterializedEvent {
+            signature: event.signature.clone(),
+            slot: event.slot,
+            decoded_family: event.event_family,
+            materialized_family: crate::MdMaterializedEventFamily::Lending,
+        }]);
+    }
+}
+
+impl crate::MtApiEventMaterializer for crate::MtLendingMaterializer {
+    fn identity(&self) -> crate::MtApiMaterializerIdentity {
+        return crate::MtApiMaterializerIdentity {
+            name: "kb_materializer_lending".to_string(),
+            version: env!("CARGO_PKG_VERSION").to_string(),
+        };
+    }
+
+    fn accepted_families(&self) -> &'static [crate::MdEventFamily] {
+        return &[];
+    }
+
+    fn transaction_policy(
+        &self,
+        _family: crate::MdEventFamily,
+    ) -> crate::MtApiMaterializationTransactionPolicy {
+        return crate::MtApiMaterializationTransactionPolicy::SuccessfulCommittedOnly;
+    }
+
+    fn materialize(
+        &self,
+        _observation: &crate::DcApiDecodedObservation,
+    ) -> crate::MtApiMaterializerExecutionResult {
+        return crate::MtApiMaterializerExecutionResult::ignored();
+    }
+}

kb-lib/src/materializer/liquidity.rs

@@ -1,6 +1,9 @@
 // file: kb-lib/src/materializer/liquidity.rs
-// version: 2
+// version: 3
 
 //! `liquidity` materializer family.
 
 mod core;
+
+/// Reserved liquidity materializer.
+pub use self::core::MtLiquidityMaterializer;

kb-lib/src/materializer/liquidity/core.rs

@@ -1,9 +1,61 @@
 // file: kb-lib/src/materializer/liquidity/core.rs
-// version: 2
+// version: 3
 
-//! Migration boundary for legacy crate `kb_materializer_liquidity`.
+//! Reserved liquidity materializer.
 
-/// Legacy crate name retained for migration and compatibility tracking.
-const LEGACY_CRATE: &str = "kb_materializer_liquidity";
-/// Current porting status.
-const MIGRATION_STATUS: &str = "source-preserved-pending-port";
+/// Reserved materializer for liquidity observations.
+#[derive(Clone, Debug, Default)]
+pub struct MtLiquidityMaterializer;
+
+impl crate::MtMaterializer for crate::MtLiquidityMaterializer {
+    fn materializer_name(&self) -> &'static str {
+        return "kb_materializer_liquidity";
+    }
+
+    fn materializer_version(&self) -> &'static str {
+        return env!("CARGO_PKG_VERSION");
+    }
+
+    fn accepts_event(&self, _event: &crate::MdDecodedProtocolEvent) -> bool {
+        return false;
+    }
+
+    fn materialize_event(
+        &self,
+        event: &crate::MdDecodedProtocolEvent,
+    ) -> kb_core::Result<std::vec::Vec<crate::MdMaterializedEvent>> {
+        return std::result::Result::Ok(std::vec![crate::MdMaterializedEvent {
+            signature: event.signature.clone(),
+            slot: event.slot,
+            decoded_family: event.event_family,
+            materialized_family: crate::MdMaterializedEventFamily::Liquidity,
+        }]);
+    }
+}
+
+impl crate::MtApiEventMaterializer for crate::MtLiquidityMaterializer {
+    fn identity(&self) -> crate::MtApiMaterializerIdentity {
+        return crate::MtApiMaterializerIdentity {
+            name: "kb_materializer_liquidity".to_string(),
+            version: env!("CARGO_PKG_VERSION").to_string(),
+        };
+    }
+
+    fn accepted_families(&self) -> &'static [crate::MdEventFamily] {
+        return &[];
+    }
+
+    fn transaction_policy(
+        &self,
+        _family: crate::MdEventFamily,
+    ) -> crate::MtApiMaterializationTransactionPolicy {
+        return crate::MtApiMaterializationTransactionPolicy::SuccessfulCommittedOnly;
+    }
+
+    fn materialize(
+        &self,
+        _observation: &crate::DcApiDecodedObservation,
+    ) -> crate::MtApiMaterializerExecutionResult {
+        return crate::MtApiMaterializerExecutionResult::ignored();
+    }
+}

kb-lib/src/materializer/nft.rs

@@ -1,6 +1,9 @@
 // file: kb-lib/src/materializer/nft.rs
-// version: 2
+// version: 3
 
 //! `nft` materializer family.
 
 mod core;
+
+/// Reserved NFT materializer.
+pub use self::core::MtNftMaterializer;

kb-lib/src/materializer/nft/core.rs

@@ -1,9 +1,61 @@
 // file: kb-lib/src/materializer/nft/core.rs
-// version: 2
+// version: 3
 
-//! Migration boundary for legacy crate `kb_materializer_nft`.
+//! Reserved NFT materializer.
 
-/// Legacy crate name retained for migration and compatibility tracking.
-const LEGACY_CRATE: &str = "kb_materializer_nft";
-/// Current porting status.
-const MIGRATION_STATUS: &str = "source-preserved-pending-port";
+/// Reserved materializer for NFT observations.
+#[derive(Clone, Debug, Default)]
+pub struct MtNftMaterializer;
+
+impl crate::MtMaterializer for crate::MtNftMaterializer {
+    fn materializer_name(&self) -> &'static str {
+        return "kb_materializer_nft";
+    }
+
+    fn materializer_version(&self) -> &'static str {
+        return env!("CARGO_PKG_VERSION");
+    }
+
+    fn accepts_event(&self, _event: &crate::MdDecodedProtocolEvent) -> bool {
+        return false;
+    }
+
+    fn materialize_event(
+        &self,
+        event: &crate::MdDecodedProtocolEvent,
+    ) -> kb_core::Result<std::vec::Vec<crate::MdMaterializedEvent>> {
+        return std::result::Result::Ok(std::vec![crate::MdMaterializedEvent {
+            signature: event.signature.clone(),
+            slot: event.slot,
+            decoded_family: event.event_family,
+            materialized_family: crate::MdMaterializedEventFamily::Nft,
+        }]);
+    }
+}
+
+impl crate::MtApiEventMaterializer for crate::MtNftMaterializer {
+    fn identity(&self) -> crate::MtApiMaterializerIdentity {
+        return crate::MtApiMaterializerIdentity {
+            name: "kb_materializer_nft".to_string(),
+            version: env!("CARGO_PKG_VERSION").to_string(),
+        };
+    }
+
+    fn accepted_families(&self) -> &'static [crate::MdEventFamily] {
+        return &[];
+    }
+
+    fn transaction_policy(
+        &self,
+        _family: crate::MdEventFamily,
+    ) -> crate::MtApiMaterializationTransactionPolicy {
+        return crate::MtApiMaterializationTransactionPolicy::SuccessfulCommittedOnly;
+    }
+
+    fn materialize(
+        &self,
+        _observation: &crate::DcApiDecodedObservation,
+    ) -> crate::MtApiMaterializerExecutionResult {
+        return crate::MtApiMaterializerExecutionResult::ignored();
+    }
+}

kb-lib/src/materializer/oracle.rs

@@ -1,6 +1,9 @@
 // file: kb-lib/src/materializer/oracle.rs
-// version: 2
+// version: 3
 
 //! `oracle` materializer family.
 
 mod core;
+
+/// Reserved oracle materializer.
+pub use self::core::MtOracleMaterializer;

kb-lib/src/materializer/oracle/core.rs

@@ -1,9 +1,61 @@
 // file: kb-lib/src/materializer/oracle/core.rs
-// version: 2
+// version: 3
 
-//! Migration boundary for legacy crate `kb_materializer_oracle`.
+//! Reserved oracle materializer.
 
-/// Legacy crate name retained for migration and compatibility tracking.
-const LEGACY_CRATE: &str = "kb_materializer_oracle";
-/// Current porting status.
-const MIGRATION_STATUS: &str = "source-preserved-pending-port";
+/// Reserved materializer for oracle observations.
+#[derive(Clone, Debug, Default)]
+pub struct MtOracleMaterializer;
+
+impl crate::MtMaterializer for crate::MtOracleMaterializer {
+    fn materializer_name(&self) -> &'static str {
+        return "kb_materializer_oracle";
+    }
+
+    fn materializer_version(&self) -> &'static str {
+        return env!("CARGO_PKG_VERSION");
+    }
+
+    fn accepts_event(&self, _event: &crate::MdDecodedProtocolEvent) -> bool {
+        return false;
+    }
+
+    fn materialize_event(
+        &self,
+        event: &crate::MdDecodedProtocolEvent,
+    ) -> kb_core::Result<std::vec::Vec<crate::MdMaterializedEvent>> {
+        return std::result::Result::Ok(std::vec![crate::MdMaterializedEvent {
+            signature: event.signature.clone(),
+            slot: event.slot,
+            decoded_family: event.event_family,
+            materialized_family: crate::MdMaterializedEventFamily::Oracle,
+        }]);
+    }
+}
+
+impl crate::MtApiEventMaterializer for crate::MtOracleMaterializer {
+    fn identity(&self) -> crate::MtApiMaterializerIdentity {
+        return crate::MtApiMaterializerIdentity {
+            name: "kb_materializer_oracle".to_string(),
+            version: env!("CARGO_PKG_VERSION").to_string(),
+        };
+    }
+
+    fn accepted_families(&self) -> &'static [crate::MdEventFamily] {
+        return &[];
+    }
+
+    fn transaction_policy(
+        &self,
+        _family: crate::MdEventFamily,
+    ) -> crate::MtApiMaterializationTransactionPolicy {
+        return crate::MtApiMaterializationTransactionPolicy::SuccessfulCommittedOnly;
+    }
+
+    fn materialize(
+        &self,
+        _observation: &crate::DcApiDecodedObservation,
+    ) -> crate::MtApiMaterializerExecutionResult {
+        return crate::MtApiMaterializerExecutionResult::ignored();
+    }
+}

kb-lib/src/materializer/orderbook.rs

@@ -1,6 +1,9 @@
 // file: kb-lib/src/materializer/orderbook.rs
-// version: 2
+// version: 3
 
 //! `orderbook` materializer family.
 
 mod core;
+
+/// Reserved orderbook materializer.
+pub use self::core::MtOrderbookMaterializer;

kb-lib/src/materializer/orderbook/core.rs

@@ -1,9 +1,61 @@
 // file: kb-lib/src/materializer/orderbook/core.rs
-// version: 2
+// version: 3
 
-//! Migration boundary for legacy crate `kb_materializer_orderbook`.
+//! Reserved orderbook materializer.
 
-/// Legacy crate name retained for migration and compatibility tracking.
-const LEGACY_CRATE: &str = "kb_materializer_orderbook";
-/// Current porting status.
-const MIGRATION_STATUS: &str = "source-preserved-pending-port";
+/// Reserved materializer for orderbook observations.
+#[derive(Clone, Debug, Default)]
+pub struct MtOrderbookMaterializer;
+
+impl crate::MtMaterializer for crate::MtOrderbookMaterializer {
+    fn materializer_name(&self) -> &'static str {
+        return "kb_materializer_orderbook";
+    }
+
+    fn materializer_version(&self) -> &'static str {
+        return env!("CARGO_PKG_VERSION");
+    }
+
+    fn accepts_event(&self, _event: &crate::MdDecodedProtocolEvent) -> bool {
+        return false;
+    }
+
+    fn materialize_event(
+        &self,
+        event: &crate::MdDecodedProtocolEvent,
+    ) -> kb_core::Result<std::vec::Vec<crate::MdMaterializedEvent>> {
+        return std::result::Result::Ok(std::vec![crate::MdMaterializedEvent {
+            signature: event.signature.clone(),
+            slot: event.slot,
+            decoded_family: event.event_family,
+            materialized_family: crate::MdMaterializedEventFamily::Orderbook,
+        }]);
+    }
+}
+
+impl crate::MtApiEventMaterializer for crate::MtOrderbookMaterializer {
+    fn identity(&self) -> crate::MtApiMaterializerIdentity {
+        return crate::MtApiMaterializerIdentity {
+            name: "kb_materializer_orderbook".to_string(),
+            version: env!("CARGO_PKG_VERSION").to_string(),
+        };
+    }
+
+    fn accepted_families(&self) -> &'static [crate::MdEventFamily] {
+        return &[];
+    }
+
+    fn transaction_policy(
+        &self,
+        _family: crate::MdEventFamily,
+    ) -> crate::MtApiMaterializationTransactionPolicy {
+        return crate::MtApiMaterializationTransactionPolicy::SuccessfulCommittedOnly;
+    }
+
+    fn materialize(
+        &self,
+        _observation: &crate::DcApiDecodedObservation,
+    ) -> crate::MtApiMaterializerExecutionResult {
+        return crate::MtApiMaterializerExecutionResult::ignored();
+    }
+}

kb-lib/src/materializer/perpetuals.rs

@@ -1,6 +1,9 @@
 // file: kb-lib/src/materializer/perpetuals.rs
-// version: 2
+// version: 3
 
 //! `perpetuals` materializer family.
 
 mod core;
+
+/// Reserved perpetuals materializer.
+pub use self::core::MtPerpetualsMaterializer;

kb-lib/src/materializer/perpetuals/core.rs

@@ -1,9 +1,61 @@
 // file: kb-lib/src/materializer/perpetuals/core.rs
-// version: 2
+// version: 3
 
-//! Migration boundary for legacy crate `kb_materializer_perpetuals`.
+//! Reserved perpetuals materializer.
 
-/// Legacy crate name retained for migration and compatibility tracking.
-const LEGACY_CRATE: &str = "kb_materializer_perpetuals";
-/// Current porting status.
-const MIGRATION_STATUS: &str = "source-preserved-pending-port";
+/// Reserved materializer for perpetuals observations.
+#[derive(Clone, Debug, Default)]
+pub struct MtPerpetualsMaterializer;
+
+impl crate::MtMaterializer for crate::MtPerpetualsMaterializer {
+    fn materializer_name(&self) -> &'static str {
+        return "kb_materializer_perpetuals";
+    }
+
+    fn materializer_version(&self) -> &'static str {
+        return env!("CARGO_PKG_VERSION");
+    }
+
+    fn accepts_event(&self, _event: &crate::MdDecodedProtocolEvent) -> bool {
+        return false;
+    }
+
+    fn materialize_event(
+        &self,
+        event: &crate::MdDecodedProtocolEvent,
+    ) -> kb_core::Result<std::vec::Vec<crate::MdMaterializedEvent>> {
+        return std::result::Result::Ok(std::vec![crate::MdMaterializedEvent {
+            signature: event.signature.clone(),
+            slot: event.slot,
+            decoded_family: event.event_family,
+            materialized_family: crate::MdMaterializedEventFamily::Perpetuals,
+        }]);
+    }
+}
+
+impl crate::MtApiEventMaterializer for crate::MtPerpetualsMaterializer {
+    fn identity(&self) -> crate::MtApiMaterializerIdentity {
+        return crate::MtApiMaterializerIdentity {
+            name: "kb_materializer_perpetuals".to_string(),
+            version: env!("CARGO_PKG_VERSION").to_string(),
+        };
+    }
+
+    fn accepted_families(&self) -> &'static [crate::MdEventFamily] {
+        return &[];
+    }
+
+    fn transaction_policy(
+        &self,
+        _family: crate::MdEventFamily,
+    ) -> crate::MtApiMaterializationTransactionPolicy {
+        return crate::MtApiMaterializationTransactionPolicy::SuccessfulCommittedOnly;
+    }
+
+    fn materialize(
+        &self,
+        _observation: &crate::DcApiDecodedObservation,
+    ) -> crate::MtApiMaterializerExecutionResult {
+        return crate::MtApiMaterializerExecutionResult::ignored();
+    }
+}

kb-lib/src/materializer/pool.rs

@@ -1,6 +1,9 @@
 // file: kb-lib/src/materializer/pool.rs
-// version: 2
+// version: 3
 
 //! `pool` materializer family.
 
 mod state;
+
+/// Reserved pool-state materializer.
+pub use self::state::MtPoolStateMaterializer;

kb-lib/src/materializer/pool/state.rs

@@ -1,9 +1,61 @@
 // file: kb-lib/src/materializer/pool/state.rs
-// version: 2
+// version: 3
 
-//! Migration boundary for legacy crate `kb_materializer_pool_state`.
+//! Reserved pool-state materializer.
 
-/// Legacy crate name retained for migration and compatibility tracking.
-const LEGACY_CRATE: &str = "kb_materializer_pool_state";
-/// Current porting status.
-const MIGRATION_STATUS: &str = "source-preserved-pending-port";
+/// Reserved materializer for pool-state observations.
+#[derive(Clone, Debug, Default)]
+pub struct MtPoolStateMaterializer;
+
+impl crate::MtMaterializer for crate::MtPoolStateMaterializer {
+    fn materializer_name(&self) -> &'static str {
+        return "kb_materializer_pool_state";
+    }
+
+    fn materializer_version(&self) -> &'static str {
+        return env!("CARGO_PKG_VERSION");
+    }
+
+    fn accepts_event(&self, _event: &crate::MdDecodedProtocolEvent) -> bool {
+        return false;
+    }
+
+    fn materialize_event(
+        &self,
+        event: &crate::MdDecodedProtocolEvent,
+    ) -> kb_core::Result<std::vec::Vec<crate::MdMaterializedEvent>> {
+        return std::result::Result::Ok(std::vec![crate::MdMaterializedEvent {
+            signature: event.signature.clone(),
+            slot: event.slot,
+            decoded_family: event.event_family,
+            materialized_family: crate::MdMaterializedEventFamily::PoolState,
+        }]);
+    }
+}
+
+impl crate::MtApiEventMaterializer for crate::MtPoolStateMaterializer {
+    fn identity(&self) -> crate::MtApiMaterializerIdentity {
+        return crate::MtApiMaterializerIdentity {
+            name: "kb_materializer_pool_state".to_string(),
+            version: env!("CARGO_PKG_VERSION").to_string(),
+        };
+    }
+
+    fn accepted_families(&self) -> &'static [crate::MdEventFamily] {
+        return &[];
+    }
+
+    fn transaction_policy(
+        &self,
+        _family: crate::MdEventFamily,
+    ) -> crate::MtApiMaterializationTransactionPolicy {
+        return crate::MtApiMaterializationTransactionPolicy::SuccessfulCommittedOnly;
+    }
+
+    fn materialize(
+        &self,
+        _observation: &crate::DcApiDecodedObservation,
+    ) -> crate::MtApiMaterializerExecutionResult {
+        return crate::MtApiMaterializerExecutionResult::ignored();
+    }
+}

kb-lib/src/materializer/rewards.rs

@@ -1,6 +1,9 @@
 // file: kb-lib/src/materializer/rewards.rs
-// version: 2
+// version: 3
 
 //! `rewards` materializer family.
 
 mod core;
+
+/// Reserved rewards materializer.
+pub use self::core::MtRewardsMaterializer;

kb-lib/src/materializer/rewards/core.rs

@@ -1,9 +1,61 @@
 // file: kb-lib/src/materializer/rewards/core.rs
-// version: 2
+// version: 3
 
-//! Migration boundary for legacy crate `kb_materializer_rewards`.
+//! Reserved rewards materializer.
 
-/// Legacy crate name retained for migration and compatibility tracking.
-const LEGACY_CRATE: &str = "kb_materializer_rewards";
-/// Current porting status.
-const MIGRATION_STATUS: &str = "source-preserved-pending-port";
+/// Reserved materializer for reward observations.
+#[derive(Clone, Debug, Default)]
+pub struct MtRewardsMaterializer;
+
+impl crate::MtMaterializer for crate::MtRewardsMaterializer {
+    fn materializer_name(&self) -> &'static str {
+        return "kb_materializer_rewards";
+    }
+
+    fn materializer_version(&self) -> &'static str {
+        return env!("CARGO_PKG_VERSION");
+    }
+
+    fn accepts_event(&self, _event: &crate::MdDecodedProtocolEvent) -> bool {
+        return false;
+    }
+
+    fn materialize_event(
+        &self,
+        event: &crate::MdDecodedProtocolEvent,
+    ) -> kb_core::Result<std::vec::Vec<crate::MdMaterializedEvent>> {
+        return std::result::Result::Ok(std::vec![crate::MdMaterializedEvent {
+            signature: event.signature.clone(),
+            slot: event.slot,
+            decoded_family: event.event_family,
+            materialized_family: crate::MdMaterializedEventFamily::Reward,
+        }]);
+    }
+}
+
+impl crate::MtApiEventMaterializer for crate::MtRewardsMaterializer {
+    fn identity(&self) -> crate::MtApiMaterializerIdentity {
+        return crate::MtApiMaterializerIdentity {
+            name: "kb_materializer_rewards".to_string(),
+            version: env!("CARGO_PKG_VERSION").to_string(),
+        };
+    }
+
+    fn accepted_families(&self) -> &'static [crate::MdEventFamily] {
+        return &[];
+    }
+
+    fn transaction_policy(
+        &self,
+        _family: crate::MdEventFamily,
+    ) -> crate::MtApiMaterializationTransactionPolicy {
+        return crate::MtApiMaterializationTransactionPolicy::SuccessfulCommittedOnly;
+    }
+
+    fn materialize(
+        &self,
+        _observation: &crate::DcApiDecodedObservation,
+    ) -> crate::MtApiMaterializerExecutionResult {
+        return crate::MtApiMaterializerExecutionResult::ignored();
+    }
+}

kb-lib/src/materializer/routing.rs

@@ -1,6 +1,9 @@
 // file: kb-lib/src/materializer/routing.rs
-// version: 2
+// version: 3
 
 //! `routing` materializer family.
 
 mod core;
+
+/// Reserved routing materializer.
+pub use self::core::MtRoutingMaterializer;

kb-lib/src/materializer/routing/core.rs

@@ -1,9 +1,61 @@
 // file: kb-lib/src/materializer/routing/core.rs
-// version: 2
+// version: 3
 
-//! Migration boundary for legacy crate `kb_materializer_routing`.
+//! Reserved routing materializer.
 
-/// Legacy crate name retained for migration and compatibility tracking.
-const LEGACY_CRATE: &str = "kb_materializer_routing";
-/// Current porting status.
-const MIGRATION_STATUS: &str = "source-preserved-pending-port";
+/// Reserved materializer for routing observations.
+#[derive(Clone, Debug, Default)]
+pub struct MtRoutingMaterializer;
+
+impl crate::MtMaterializer for crate::MtRoutingMaterializer {
+    fn materializer_name(&self) -> &'static str {
+        return "kb_materializer_routing";
+    }
+
+    fn materializer_version(&self) -> &'static str {
+        return env!("CARGO_PKG_VERSION");
+    }
+
+    fn accepts_event(&self, _event: &crate::MdDecodedProtocolEvent) -> bool {
+        return false;
+    }
+
+    fn materialize_event(
+        &self,
+        event: &crate::MdDecodedProtocolEvent,
+    ) -> kb_core::Result<std::vec::Vec<crate::MdMaterializedEvent>> {
+        return std::result::Result::Ok(std::vec![crate::MdMaterializedEvent {
+            signature: event.signature.clone(),
+            slot: event.slot,
+            decoded_family: event.event_family,
+            materialized_family: crate::MdMaterializedEventFamily::Routing,
+        }]);
+    }
+}
+
+impl crate::MtApiEventMaterializer for crate::MtRoutingMaterializer {
+    fn identity(&self) -> crate::MtApiMaterializerIdentity {
+        return crate::MtApiMaterializerIdentity {
+            name: "kb_materializer_routing".to_string(),
+            version: env!("CARGO_PKG_VERSION").to_string(),
+        };
+    }
+
+    fn accepted_families(&self) -> &'static [crate::MdEventFamily] {
+        return &[];
+    }
+
+    fn transaction_policy(
+        &self,
+        _family: crate::MdEventFamily,
+    ) -> crate::MtApiMaterializationTransactionPolicy {
+        return crate::MtApiMaterializationTransactionPolicy::SuccessfulCommittedOnly;
+    }
+
+    fn materialize(
+        &self,
+        _observation: &crate::DcApiDecodedObservation,
+    ) -> crate::MtApiMaterializerExecutionResult {
+        return crate::MtApiMaterializerExecutionResult::ignored();
+    }
+}

kb-lib/src/materializer/token.rs

@@ -1,5 +1,5 @@
 // file: kb-lib/src/materializer/token.rs
-// version: 3
+// version: 4
 
 //! `token` materializer family.
 
@@ -11,6 +11,8 @@ mod metadata_risk;
 pub use self::accounts::MtTokenAccountsMaterializer;
 /// Materializes one bounded Token-2022 account state snapshot.
 pub use self::accounts::materializer_token_materialize_token2022_state_snapshot;
+/// Reserved token-metadata risk materializer.
+pub use self::metadata_risk::MtTokenMetadataRiskMaterializer;
 
 /// Stable processor name for Token, ATA and Token-2022 account projections.
 pub(crate) use self::constants::MT_TOKEN_ACCOUNTS_PROCESSOR_NAME;

kb-lib/src/materializer/token/metadata_risk.rs

@@ -1,9 +1,61 @@
 // file: kb-lib/src/materializer/token/metadata_risk.rs
-// version: 2
+// version: 3
 
-//! Migration boundary for legacy crate `kb_materializer_token_metadata_risk`.
+//! Reserved token-metadata risk materializer.
 
-/// Legacy crate name retained for migration and compatibility tracking.
-const LEGACY_CRATE: &str = "kb_materializer_token_metadata_risk";
-/// Current porting status.
-const MIGRATION_STATUS: &str = "source-preserved-pending-port";
+/// Reserved materializer for token-metadata risk observations.
+#[derive(Clone, Debug, Default)]
+pub struct MtTokenMetadataRiskMaterializer;
+
+impl crate::MtMaterializer for crate::MtTokenMetadataRiskMaterializer {
+    fn materializer_name(&self) -> &'static str {
+        return "kb_materializer_token_metadata_risk";
+    }
+
+    fn materializer_version(&self) -> &'static str {
+        return env!("CARGO_PKG_VERSION");
+    }
+
+    fn accepts_event(&self, _event: &crate::MdDecodedProtocolEvent) -> bool {
+        return false;
+    }
+
+    fn materialize_event(
+        &self,
+        event: &crate::MdDecodedProtocolEvent,
+    ) -> kb_core::Result<std::vec::Vec<crate::MdMaterializedEvent>> {
+        return std::result::Result::Ok(std::vec![crate::MdMaterializedEvent {
+            signature: event.signature.clone(),
+            slot: event.slot,
+            decoded_family: event.event_family,
+            materialized_family: crate::MdMaterializedEventFamily::TokenMetadataRisk,
+        }]);
+    }
+}
+
+impl crate::MtApiEventMaterializer for crate::MtTokenMetadataRiskMaterializer {
+    fn identity(&self) -> crate::MtApiMaterializerIdentity {
+        return crate::MtApiMaterializerIdentity {
+            name: "kb_materializer_token_metadata_risk".to_string(),
+            version: env!("CARGO_PKG_VERSION").to_string(),
+        };
+    }
+
+    fn accepted_families(&self) -> &'static [crate::MdEventFamily] {
+        return &[];
+    }
+
+    fn transaction_policy(
+        &self,
+        _family: crate::MdEventFamily,
+    ) -> crate::MtApiMaterializationTransactionPolicy {
+        return crate::MtApiMaterializationTransactionPolicy::SuccessfulCommittedOnly;
+    }
+
+    fn materialize(
+        &self,
+        _observation: &crate::DcApiDecodedObservation,
+    ) -> crate::MtApiMaterializerExecutionResult {
+        return crate::MtApiMaterializerExecutionResult::ignored();
+    }
+}

kb-lib/src/materializer/trades.rs

@@ -1,6 +1,9 @@
 // file: kb-lib/src/materializer/trades.rs
-// version: 2
+// version: 3
 
 //! `trades` materializer family.
 
 mod core;
+
+/// Reserved trades materializer.
+pub use self::core::MtTradesMaterializer;

kb-lib/src/materializer/trades/core.rs

@@ -1,9 +1,61 @@
 // file: kb-lib/src/materializer/trades/core.rs
-// version: 2
+// version: 3
 
-//! Migration boundary for legacy crate `kb_materializer_trades`.
+//! Reserved trades materializer.
 
-/// Legacy crate name retained for migration and compatibility tracking.
-const LEGACY_CRATE: &str = "kb_materializer_trades";
-/// Current porting status.
-const MIGRATION_STATUS: &str = "source-preserved-pending-port";
+/// Reserved materializer for trade observations.
+#[derive(Clone, Debug, Default)]
+pub struct MtTradesMaterializer;
+
+impl crate::MtMaterializer for crate::MtTradesMaterializer {
+    fn materializer_name(&self) -> &'static str {
+        return "kb_materializer_trades";
+    }
+
+    fn materializer_version(&self) -> &'static str {
+        return env!("CARGO_PKG_VERSION");
+    }
+
+    fn accepts_event(&self, _event: &crate::MdDecodedProtocolEvent) -> bool {
+        return false;
+    }
+
+    fn materialize_event(
+        &self,
+        event: &crate::MdDecodedProtocolEvent,
+    ) -> kb_core::Result<std::vec::Vec<crate::MdMaterializedEvent>> {
+        return std::result::Result::Ok(std::vec![crate::MdMaterializedEvent {
+            signature: event.signature.clone(),
+            slot: event.slot,
+            decoded_family: event.event_family,
+            materialized_family: crate::MdMaterializedEventFamily::Trade,
+        }]);
+    }
+}
+
+impl crate::MtApiEventMaterializer for crate::MtTradesMaterializer {
+    fn identity(&self) -> crate::MtApiMaterializerIdentity {
+        return crate::MtApiMaterializerIdentity {
+            name: "kb_materializer_trades".to_string(),
+            version: env!("CARGO_PKG_VERSION").to_string(),
+        };
+    }
+
+    fn accepted_families(&self) -> &'static [crate::MdEventFamily] {
+        return &[];
+    }
+
+    fn transaction_policy(
+        &self,
+        _family: crate::MdEventFamily,
+    ) -> crate::MtApiMaterializationTransactionPolicy {
+        return crate::MtApiMaterializationTransactionPolicy::SuccessfulCommittedOnly;
+    }
+
+    fn materialize(
+        &self,
+        _observation: &crate::DcApiDecodedObservation,
+    ) -> crate::MtApiMaterializerExecutionResult {
+        return crate::MtApiMaterializerExecutionResult::ignored();
+    }
+}

kb-lib/src/materializer/vault.rs

@@ -1,6 +1,9 @@
 // file: kb-lib/src/materializer/vault.rs
-// version: 2
+// version: 3
 
 //! `vault` materializer family.
 
 mod core;
+
+/// Reserved vault materializer.
+pub use self::core::MtVaultMaterializer;

kb-lib/src/materializer/vault/core.rs

@@ -1,9 +1,61 @@
 // file: kb-lib/src/materializer/vault/core.rs
-// version: 2
+// version: 3
 
-//! Migration boundary for legacy crate `kb_materializer_vault`.
+//! Reserved vault materializer.
 
-/// Legacy crate name retained for migration and compatibility tracking.
-const LEGACY_CRATE: &str = "kb_materializer_vault";
-/// Current porting status.
-const MIGRATION_STATUS: &str = "source-preserved-pending-port";
+/// Reserved materializer for vault observations.
+#[derive(Clone, Debug, Default)]
+pub struct MtVaultMaterializer;
+
+impl crate::MtMaterializer for crate::MtVaultMaterializer {
+    fn materializer_name(&self) -> &'static str {
+        return "kb_materializer_vault";
+    }
+
+    fn materializer_version(&self) -> &'static str {
+        return env!("CARGO_PKG_VERSION");
+    }
+
+    fn accepts_event(&self, _event: &crate::MdDecodedProtocolEvent) -> bool {
+        return false;
+    }
+
+    fn materialize_event(
+        &self,
+        event: &crate::MdDecodedProtocolEvent,
+    ) -> kb_core::Result<std::vec::Vec<crate::MdMaterializedEvent>> {
+        return std::result::Result::Ok(std::vec![crate::MdMaterializedEvent {
+            signature: event.signature.clone(),
+            slot: event.slot,
+            decoded_family: event.event_family,
+            materialized_family: crate::MdMaterializedEventFamily::Vault,
+        }]);
+    }
+}
+
+impl crate::MtApiEventMaterializer for crate::MtVaultMaterializer {
+    fn identity(&self) -> crate::MtApiMaterializerIdentity {
+        return crate::MtApiMaterializerIdentity {
+            name: "kb_materializer_vault".to_string(),
+            version: env!("CARGO_PKG_VERSION").to_string(),
+        };
+    }
+
+    fn accepted_families(&self) -> &'static [crate::MdEventFamily] {
+        return &[];
+    }
+
+    fn transaction_policy(
+        &self,
+        _family: crate::MdEventFamily,
+    ) -> crate::MtApiMaterializationTransactionPolicy {
+        return crate::MtApiMaterializationTransactionPolicy::SuccessfulCommittedOnly;
+    }
+
+    fn materialize(
+        &self,
+        _observation: &crate::DcApiDecodedObservation,
+    ) -> crate::MtApiMaterializerExecutionResult {
+        return crate::MtApiMaterializerExecutionResult::ignored();
+    }
+}