v0.1.0-pre.013

CHANGELOG.md

@@ -1,8 +1,15 @@
 <!-- file: CHANGELOG.md -->
-<!-- version: 1 -->
+<!-- version: 2 -->
 
 # CHANGELOG
 
+## 0.1.0-pre.013
+
+- Remplacement des 14 marqueurs temporaires de matérialisation par des squelettes `Mt*Materializer`.
+- Conservation du contrat historique `MtMaterializer` et ajout du contrat bot3 `MtApiEventMaterializer`.
+- Réexports publics exclusivement depuis la façade `kb_lib`.
+- Alignement de l’audit des réexports sur l’ordre naturel produit par `rustfmt`.
+
 ## 0.1.0-pre.001
 
 - Renommage de `kb_wallet` en `kb-wallet`.

README.md

@@ -1,5 +1,5 @@
 <!-- file: README.md -->
-<!-- version: 9 -->
+<!-- version: 10 -->
 
 # Khadhroony Bot3
 
@@ -81,3 +81,5 @@ Les identités historiques des processors sont conservées pour la compatibilit
 - `MtMetadataMaterializer` pour les snapshots descriptifs Token‑2022 et Metaplex, sans fetch off-chain.
 
 Les modules de matérialisation sont privés. Tous les contrats, types concrets et helpers destinés aux consommateurs externes sont exposés exclusivement par `kb-lib/src/lib.rs`. Des tests aval distincts protègent les contrats d’extension `DcApiProtocolDecoder`, `MtApiEventMaterializer` et `ExApiInstructionExecutor`.
+
+`0.1.0-pre.013` remplace les 14 dernières frontières temporaires de matérialisation par des squelettes `Mt*Materializer`. Ils conservent le contrat historique `MtMaterializer`, implémentent également `MtApiEventMaterializer`, restent volontairement inactifs et ne produisent aucun faux événement via l’API bot3. Tous les types sont accessibles exclusivement depuis la façade `kb_lib`.

ROADMAP.md

@@ -1,5 +1,5 @@
 <!-- file: ROADMAP.md -->
-<!-- version: 11 -->
+<!-- version: 12 -->
 
 # ROADMAP — khadhroony-bot3
 
@@ -151,6 +151,18 @@
 - [x] Exposer tous les types exclusivement par la façade `kb-lib/src/lib.rs`.
 - [x] Supprimer `DC_MIGRATION_BOUNDARIES`, `*_LEGACY_CRATE` et `*_MIGRATION_STATUS` de l’arborescence des décodeurs.
 - [x] Ajouter un test central de contrat pour les 98 squelettes et étendre l’audit contre le retour des marqueurs temporaires.
-- [ ] Valider le nouveau test unitaire, les 130 Program IDs, Clippy et le workspace avec Cargo sur la machine de développement.
+- [x] Valider le nouveau test unitaire, les 130 Program IDs, Clippy et le workspace avec Cargo sur la machine de développement.
-- [ ] Vérifier puis restaurer les squelettes des familles de matérialisation encore vides.
+- [x] Vérifier puis restaurer les squelettes des familles de matérialisation encore vides.
 - [ ] Passer ensuite à l’API des exécuteurs, à leurs squelettes puis au port des exécuteurs déjà implémentés dans bot2.
+
+### 0.1.0-pre.013 — Squelettes des matérialisateurs réservés
+
+- [x] Remplacer les 14 frontières `LEGACY_CRATE`/`MIGRATION_STATUS` par des types `Mt*Materializer` concrets.
+- [x] Conserver le contrat historique `MtMaterializer` et implémenter le contrat bot3 `MtApiEventMaterializer`.
+- [x] Maintenir les squelettes inactifs : aucune famille acceptée et résultat API `Ignored`.
+- [x] Préserver la famille de sortie historique pour les appels directs via l’ancien contrat.
+- [x] Exposer les 14 types uniquement depuis la façade `kb-lib/src/lib.rs`.
+- [x] Étendre le test aval et l’audit contre le retour des marqueurs temporaires.
+- [x] Aligner `RUST023` sur l’ordre naturel produit par `rustfmt`.
+- [ ] Valider les deux nouveaux tests unitaires, le test aval, Clippy et le workspace avec Cargo sur la machine de développement.
+- [ ] Passer à l’API des exécuteurs, à leurs squelettes puis au port des exécuteurs déjà implémentés dans bot2.

RULES.md

@@ -1,5 +1,5 @@
 <!-- file: RULES.md -->
-<!-- version: 21 -->
+<!-- version: 22 -->
 
 # Règles spécifiques à `khadhroony-bot3`
 
@@ -17,7 +17,7 @@ Toute livraison doit exécuter l'audit `python3 scripts/audit_rust_workspace_rul
 - Les packages Rust utilisent le préfixe `kb-` ; leur identifiant Rust correspondant utilise automatiquement `kb_`.
 - Les décodeurs, matérialisateurs et exécuteurs sont des modules de `kb-lib`, pas des crates séparées.
 - Le crate de journalisation s'appelle `kb-logging`.
-- Les blocs consécutifs de réexports `pub use` et `pub(crate) use` ne contiennent aucune ligne vide interne et restent ordonnés alphabétiquement lorsque `cargo fmt` ne les réordonne pas.
+- Les réexports sont regroupés par visibilité : le bloc `pub use` précède le bloc séparé `pub(crate) use`, sans ligne vide interne à un bloc ; leur ordre naturel doit rester compatible avec `cargo fmt`.
 - Les familles de symboles consolidées dans `kb-lib` utilisent les préfixes `DC_`/`Dc`/`decoder_` pour les décodeurs, `MT_`/`Mt`/`materializer_` pour les matérialisateurs, `EX_`/`Ex`/`executor_` pour les exécuteurs et `MD_`/`Md`/`model_` pour les modèles.
 - Les méthodes inhérentes et helpers strictement privés peuvent conserver un nom local court ; les préfixes s’appliquent aux constantes, types, traits et fonctions libres exposés à la crate ou hors de la crate.
 - Les constantes temporaires `*_LEGACY_CRATE`, `*_MIGRATION_STATUS` et `*_MIGRATION_BOUNDARIES` doivent disparaître d’une famille dès que ses squelettes typés sont restaurés ; elles ne constituent jamais une API durable.

RUST_RULES.md

@@ -1,5 +1,5 @@
 <!-- file: RUST_RULES.md -->
-<!-- version: 4 -->
+<!-- version: 5 -->
 
 # Règles Rust générales
 
@@ -67,6 +67,8 @@ implicit_saturating_sub = "allow"
 - Les lignes vides séparent uniquement les fonctions, blocs `impl`, types et sections logiques.
 - Les exports de `lib.rs` ou `main.rs` ne contiennent aucune ligne vide à l'intérieur d'une série homogène de `pub use` ou `pub(crate) use`.
 - Les séries `pub use` et `pub(crate) use` forment deux groupes séparés lorsqu'elles coexistent.
+- Le groupe `pub use` précède le groupe `pub(crate) use` dans une même façade.
+- L’ordre interne suit l’ordre naturel produit par `rustfmt` : les segments et mots séparés sont comparés avant leurs suffixes numériques, par exemple `U8` avant `U16` et `TOKEN` avant `TOKEN2022`.
 
 ## Imports et chemins
 

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.
+#[cfg(test)]
-pub use self::admin::MtAdminMaterializer;
+mod tests {
-/// Materializes one exact SPL ElGamal registry account snapshot.
+    #[test]
-pub use self::admin::materializer_admin_materialize_elgamal_registry_state_snapshot;
+    fn reserved_materializers_expose_inactive_public_contracts() {
-/// Materializes exact Token-2022 administration account snapshots.
+        let materializers: &[(&dyn crate::MtApiEventMaterializer, &str)] = &[
-pub use self::admin::materializer_admin_materialize_token2022_state_snapshots;
+            (&crate::MtBridgeMaterializer, "kb_materializer_bridge"),
-/// Stable decoded observation materializer contract used by the common pipeline.
+            (&crate::MtGovernanceMaterializer, "kb_materializer_governance"),
-pub use self::api::MtApiEventMaterializer;
+            (&crate::MtLendingMaterializer, "kb_materializer_lending"),
-/// Explicit policy applied to successful and failed source transactions.
+            (&crate::MtLiquidityMaterializer, "kb_materializer_liquidity"),
-pub use self::api::MtApiMaterializationTransactionPolicy;
+            (&crate::MtNftMaterializer, "kb_materializer_nft"),
-/// Stable processor-owned business output derived from one decoded observation.
+            (&crate::MtOracleMaterializer, "kb_materializer_oracle"),
-pub use self::api::MtApiMaterializedOutput;
+            (&crate::MtOrderbookMaterializer, "kb_materializer_orderbook"),
-/// Structured materializer diagnostic without generic error wrappers.
+            (&crate::MtPerpetualsMaterializer, "kb_materializer_perpetuals"),
-pub use self::api::MtApiMaterializerDiagnostic;
+            (&crate::MtPoolStateMaterializer, "kb_materializer_pool_state"),
-/// Complete explicit result produced by one materializer invocation.
+            (&crate::MtRewardsMaterializer, "kb_materializer_rewards"),
-pub use self::api::MtApiMaterializerExecutionResult;
+            (&crate::MtRoutingMaterializer, "kb_materializer_routing"),
-/// Stable identity of one decoded event materializer.
+            (&crate::MtTokenMetadataRiskMaterializer, "kb_materializer_token_metadata_risk"),
-pub use self::api::MtApiMaterializerIdentity;
+            (&crate::MtTradesMaterializer, "kb_materializer_trades"),
-/// Terminal materializer result status.
+            (&crate::MtVaultMaterializer, "kb_materializer_vault"),
-pub use self::api::MtApiMaterializerOutcomeStatus;
+        ];
-/// Exposes the legacy common business materializer trait.
+        for (materializer, expected_name) in materializers {
-pub use self::api::MtMaterializer;
+            let identity = materializer.identity();
-/// Returns true when a materializer explicitly accepts one decoded family.
+            assert_eq!(identity.name, *expected_name);
-pub use self::api::materializer_api_accepts_family;
+            assert!(!identity.version.is_empty());
-/// Returns true when a materializer accepts one exact decoded observation.
+            assert!(materializer.accepted_families().is_empty());
-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.
+    #[test]
-pub use self::api::materializer_api_validate_materialized_output_policy;
+    fn reserved_materializers_preserve_legacy_trait_contracts() {
-/// Stable native compliance audit materializer.
+        let materializers: &[(&dyn crate::MtMaterializer, &str)] = &[
-pub use self::compliance::MtComplianceAuditMaterializer;
+            (&crate::MtBridgeMaterializer, "kb_materializer_bridge"),
-/// Fee materializer for committed Token-2022 fee observations.
+            (&crate::MtGovernanceMaterializer, "kb_materializer_governance"),
-pub use self::fees::MtFeesMaterializer;
+            (&crate::MtLendingMaterializer, "kb_materializer_lending"),
-/// Materializes authoritative Token-2022 fee extension snapshots.
+            (&crate::MtLiquidityMaterializer, "kb_materializer_liquidity"),
-pub use self::fees::materializer_fees_materialize_token2022_state_snapshots;
+            (&crate::MtNftMaterializer, "kb_materializer_nft"),
-/// Stable native lifecycle materializer.
+            (&crate::MtOracleMaterializer, "kb_materializer_oracle"),
-pub use self::lifecycle::MtLifecycleMaterializer;
+            (&crate::MtOrderbookMaterializer, "kb_materializer_orderbook"),
-/// Token-2022 and Metaplex metadata snapshot materializer.
+            (&crate::MtPerpetualsMaterializer, "kb_materializer_perpetuals"),
-pub use self::metadata::MtMetadataMaterializer;
+            (&crate::MtPoolStateMaterializer, "kb_materializer_pool_state"),
-/// Materializes one canonical non-Metadata Metaplex account snapshot.
+            (&crate::MtRewardsMaterializer, "kb_materializer_rewards"),
-pub use self::metadata::materializer_metadata_materialize_metaplex_account_snapshot;
+            (&crate::MtRoutingMaterializer, "kb_materializer_routing"),
-/// Materializes one canonical Metaplex Metadata account snapshot.
+            (&crate::MtTokenMetadataRiskMaterializer, "kb_materializer_token_metadata_risk"),
-pub use self::metadata::materializer_metadata_materialize_metaplex_metadata_snapshot;
+            (&crate::MtTradesMaterializer, "kb_materializer_trades"),
-/// Materializes Token-2022 embedded metadata and group snapshots.
+            (&crate::MtVaultMaterializer, "kb_materializer_vault"),
-pub use self::metadata::materializer_metadata_materialize_token2022_snapshot;
+        ];
-/// Stable SPL Token and ATA risk materializer.
+        for (materializer, expected_name) in materializers {
-pub use self::risk::MtRiskMaterializer;
+            assert_eq!(materializer.materializer_name(), *expected_name);
-/// Stable native stake and vote materializer.
+            assert!(!materializer.materializer_version().is_empty());
-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;

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.
+/// Reserved materializer for bridge observations.
-const LEGACY_CRATE: &str = "kb_materializer_bridge";
+#[derive(Clone, Debug, Default)]
-/// Current porting status.
+pub struct MtBridgeMaterializer;
-const MIGRATION_STATUS: &str = "source-preserved-pending-port";
+
+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.
+/// Reserved materializer for governance observations.
-const LEGACY_CRATE: &str = "kb_materializer_governance";
+#[derive(Clone, Debug, Default)]
-/// Current porting status.
+pub struct MtGovernanceMaterializer;
-const MIGRATION_STATUS: &str = "source-preserved-pending-port";
+
+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.
+/// Reserved materializer for lending observations.
-const LEGACY_CRATE: &str = "kb_materializer_lending";
+#[derive(Clone, Debug, Default)]
-/// Current porting status.
+pub struct MtLendingMaterializer;
-const MIGRATION_STATUS: &str = "source-preserved-pending-port";
+
+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.
+/// Reserved materializer for liquidity observations.
-const LEGACY_CRATE: &str = "kb_materializer_liquidity";
+#[derive(Clone, Debug, Default)]
-/// Current porting status.
+pub struct MtLiquidityMaterializer;
-const MIGRATION_STATUS: &str = "source-preserved-pending-port";
+
+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.
+/// Reserved materializer for NFT observations.
-const LEGACY_CRATE: &str = "kb_materializer_nft";
+#[derive(Clone, Debug, Default)]
-/// Current porting status.
+pub struct MtNftMaterializer;
-const MIGRATION_STATUS: &str = "source-preserved-pending-port";
+
+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.
+/// Reserved materializer for oracle observations.
-const LEGACY_CRATE: &str = "kb_materializer_oracle";
+#[derive(Clone, Debug, Default)]
-/// Current porting status.
+pub struct MtOracleMaterializer;
-const MIGRATION_STATUS: &str = "source-preserved-pending-port";
+
+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.
+/// Reserved materializer for orderbook observations.
-const LEGACY_CRATE: &str = "kb_materializer_orderbook";
+#[derive(Clone, Debug, Default)]
-/// Current porting status.
+pub struct MtOrderbookMaterializer;
-const MIGRATION_STATUS: &str = "source-preserved-pending-port";
+
+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.
+/// Reserved materializer for perpetuals observations.
-const LEGACY_CRATE: &str = "kb_materializer_perpetuals";
+#[derive(Clone, Debug, Default)]
-/// Current porting status.
+pub struct MtPerpetualsMaterializer;
-const MIGRATION_STATUS: &str = "source-preserved-pending-port";
+
+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.
+/// Reserved materializer for pool-state observations.
-const LEGACY_CRATE: &str = "kb_materializer_pool_state";
+#[derive(Clone, Debug, Default)]
-/// Current porting status.
+pub struct MtPoolStateMaterializer;
-const MIGRATION_STATUS: &str = "source-preserved-pending-port";
+
+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.
+/// Reserved materializer for reward observations.
-const LEGACY_CRATE: &str = "kb_materializer_rewards";
+#[derive(Clone, Debug, Default)]
-/// Current porting status.
+pub struct MtRewardsMaterializer;
-const MIGRATION_STATUS: &str = "source-preserved-pending-port";
+
+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.
+/// Reserved materializer for routing observations.
-const LEGACY_CRATE: &str = "kb_materializer_routing";
+#[derive(Clone, Debug, Default)]
-/// Current porting status.
+pub struct MtRoutingMaterializer;
-const MIGRATION_STATUS: &str = "source-preserved-pending-port";
+
+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.
+/// Reserved materializer for token-metadata risk observations.
-const LEGACY_CRATE: &str = "kb_materializer_token_metadata_risk";
+#[derive(Clone, Debug, Default)]
-/// Current porting status.
+pub struct MtTokenMetadataRiskMaterializer;
-const MIGRATION_STATUS: &str = "source-preserved-pending-port";
+
+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.
+/// Reserved materializer for trade observations.
-const LEGACY_CRATE: &str = "kb_materializer_trades";
+#[derive(Clone, Debug, Default)]
-/// Current porting status.
+pub struct MtTradesMaterializer;
-const MIGRATION_STATUS: &str = "source-preserved-pending-port";
+
+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.
+/// Reserved materializer for vault observations.
-const LEGACY_CRATE: &str = "kb_materializer_vault";
+#[derive(Clone, Debug, Default)]
-/// Current porting status.
+pub struct MtVaultMaterializer;
-const MIGRATION_STATUS: &str = "source-preserved-pending-port";
+
+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();
+    }
+}

kb-lib/tests/external_materializer_api.rs

@@ -1,5 +1,5 @@
 // file: kb-lib/tests/external_materializer_api.rs
-// version: 3
+// version: 4
 
 //! Downstream-style compilation contract for externally implemented materializers.
 
@@ -44,14 +44,42 @@ fn external_materializer_uses_only_the_public_kb_lib_contract() {
     assert_eq!(materializer.identity().name, "external_audit_materializer");
     assert_eq!(materializer.accepted_families(), ACCEPTED_FAMILIES);
     assert_event_materializer::<kb_lib::MtAdminMaterializer>();
+    assert_event_materializer::<kb_lib::MtBridgeMaterializer>();
     assert_event_materializer::<kb_lib::MtComplianceAuditMaterializer>();
     assert_event_materializer::<kb_lib::MtFeesMaterializer>();
+    assert_event_materializer::<kb_lib::MtGovernanceMaterializer>();
+    assert_event_materializer::<kb_lib::MtLendingMaterializer>();
     assert_event_materializer::<kb_lib::MtLifecycleMaterializer>();
+    assert_event_materializer::<kb_lib::MtLiquidityMaterializer>();
+    assert_event_materializer::<kb_lib::MtNftMaterializer>();
+    assert_event_materializer::<kb_lib::MtOracleMaterializer>();
+    assert_event_materializer::<kb_lib::MtOrderbookMaterializer>();
+    assert_event_materializer::<kb_lib::MtPerpetualsMaterializer>();
+    assert_event_materializer::<kb_lib::MtPoolStateMaterializer>();
+    assert_event_materializer::<kb_lib::MtRewardsMaterializer>();
     assert_event_materializer::<kb_lib::MtRiskMaterializer>();
+    assert_event_materializer::<kb_lib::MtRoutingMaterializer>();
     assert_event_materializer::<kb_lib::MtStakingMaterializer>();
     assert_event_materializer::<kb_lib::MtTokenAccountsMaterializer>();
+    assert_event_materializer::<kb_lib::MtTokenMetadataRiskMaterializer>();
+    assert_event_materializer::<kb_lib::MtTradesMaterializer>();
     assert_event_materializer::<kb_lib::MtTransactionAnnotationMaterializer>();
+    assert_event_materializer::<kb_lib::MtVaultMaterializer>();
+    assert_legacy_materializer::<kb_lib::MtBridgeMaterializer>();
+    assert_legacy_materializer::<kb_lib::MtGovernanceMaterializer>();
+    assert_legacy_materializer::<kb_lib::MtLendingMaterializer>();
+    assert_legacy_materializer::<kb_lib::MtLiquidityMaterializer>();
     assert_legacy_materializer::<kb_lib::MtMetadataMaterializer>();
+    assert_legacy_materializer::<kb_lib::MtNftMaterializer>();
+    assert_legacy_materializer::<kb_lib::MtOracleMaterializer>();
+    assert_legacy_materializer::<kb_lib::MtOrderbookMaterializer>();
+    assert_legacy_materializer::<kb_lib::MtPerpetualsMaterializer>();
+    assert_legacy_materializer::<kb_lib::MtPoolStateMaterializer>();
+    assert_legacy_materializer::<kb_lib::MtRewardsMaterializer>();
+    assert_legacy_materializer::<kb_lib::MtRoutingMaterializer>();
+    assert_legacy_materializer::<kb_lib::MtTokenMetadataRiskMaterializer>();
+    assert_legacy_materializer::<kb_lib::MtTradesMaterializer>();
+    assert_legacy_materializer::<kb_lib::MtVaultMaterializer>();
     let _ = kb_lib::materializer_admin_materialize_elgamal_registry_state_snapshot;
     let _ = kb_lib::materializer_metadata_materialize_metaplex_account_snapshot;
     let _ = kb_lib::materializer_metadata_materialize_metaplex_metadata_snapshot;

scripts/audit_khadhroony_workspace_rules.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # file: scripts/audit_khadhroony_workspace_rules.py
-# version: 6
+# version: 7
 
 """Audit mechanically verifiable rules specific to khadhroony-bot3."""
 
@@ -278,6 +278,87 @@ def audit_reserved_decoder_scaffolds(root: pathlib.Path) -> list[Violation]:
     return violations
 
 
+def audit_reserved_materializer_scaffolds(root: pathlib.Path) -> list[Violation]:
+    """Reject temporary materializer markers and incomplete reserved materializers."""
+
+    violations: list[Violation] = []
+    materializer_root = root / "kb-lib/src/materializer"
+    forbidden = (
+        "MIGRATION_BOUNDARIES",
+        "LEGACY_CRATE",
+        "MIGRATION_STATUS",
+        "source-preserved-pending-port",
+    )
+    struct_pattern = re.compile(r"^pub struct (Mt[A-Za-z0-9]+Materializer);$", re.MULTILINE)
+    for path in sorted(materializer_root.rglob("*.rs")):
+        relative = path.relative_to(root).as_posix()
+        text = path.read_text(encoding="utf-8")
+        for marker in forbidden:
+            offset = text.find(marker)
+            if offset >= 0:
+                violations.append(
+                    Violation(
+                        "KH_MT001",
+                        relative,
+                        text[:offset].count("\n") + 1,
+                        f"temporary materializer migration marker `{marker}` is forbidden",
+                    )
+                )
+        if not text.startswith("// file:") or "\n//! Reserved " not in text:
+            continue
+        struct_match = struct_pattern.search(text)
+        if struct_match is None:
+            violations.append(
+                Violation(
+                    "KH_MT002",
+                    relative,
+                    1,
+                    "reserved materializer must expose one `Mt*Materializer` unit struct",
+                )
+            )
+            continue
+        type_name = struct_match.group(1)
+        legacy_implementation = f"impl crate::MtMaterializer for crate::{type_name} {{"
+        if legacy_implementation not in text:
+            violations.append(
+                Violation(
+                    "KH_MT003",
+                    relative,
+                    text[: struct_match.start()].count("\n") + 1,
+                    f"`{type_name}` must implement `MtMaterializer`",
+                )
+            )
+        api_implementation = f"impl crate::MtApiEventMaterializer for crate::{type_name} {{"
+        if api_implementation not in text:
+            violations.append(
+                Violation(
+                    "KH_MT004",
+                    relative,
+                    text[: struct_match.start()].count("\n") + 1,
+                    f"`{type_name}` must implement `MtApiEventMaterializer`",
+                )
+            )
+        if "fn accepted_families(&self) -> &'static [crate::MdEventFamily]" not in text:
+            violations.append(
+                Violation(
+                    "KH_MT005",
+                    relative,
+                    1,
+                    "reserved materializer must declare its inactive family boundary",
+                )
+            )
+        if "crate::MtApiMaterializerExecutionResult::ignored()" not in text:
+            violations.append(
+                Violation(
+                    "KH_MT006",
+                    relative,
+                    1,
+                    "reserved materializer must return an ignored API result",
+                )
+            )
+    return violations
+
+
 def audit_token2022_naming(root: pathlib.Path) -> list[Violation]:
     """Reject obsolete internal Token2022 spellings while preserving legacy evidence."""
 
@@ -421,6 +502,7 @@ def main() -> int:
         + audit_kb_lib_tracing(root)
         + audit_kb_lib_symbol_prefixes(root)
         + audit_reserved_decoder_scaffolds(root)
+        + audit_reserved_materializer_scaffolds(root)
         + audit_token2022_naming(root)
         + audit_private_kb_lib_paths_in_active_docs(root)
         + audit_solana_types(root)

scripts/audit_rust_general_rules.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # file: scripts/audit_rust_general_rules.py
-# version: 6
+# version: 7
 
 """Audit mechanically verifiable Rust rules shared by all Rust projects."""
 
@@ -38,6 +38,24 @@ def rust_files(root: pathlib.Path) -> list[pathlib.Path]:
     )
 
 
+def rustfmt_re_export_key(export_path: str) -> tuple[object, ...]:
+    """Return the natural path order used by rustfmt for separate imports."""
+
+    path = export_path.removesuffix(";")
+    segments = path.split("::")
+    root_priority = 0 if segments[0] == "self" else 1 if segments[0] == "super" else 2
+    segment_keys: list[tuple[tuple[int, object], ...]] = []
+    for segment in segments:
+        tokens: list[tuple[int, object]] = []
+        for token in re.findall(r"[A-Za-z]+|[0-9]+", segment):
+            if token.isdigit():
+                tokens.append((1, int(token)))
+            else:
+                tokens.append((0, token))
+        segment_keys.append(tuple(tokens))
+    return (root_priority, *segment_keys)
+
+
 def audit_file(root: pathlib.Path, path: pathlib.Path) -> list[Violation]:
     """Audit one Rust source against general rules."""
 
@@ -96,7 +114,7 @@ def audit_file(root: pathlib.Path, path: pathlib.Path) -> list[Violation]:
             violations.append(Violation("RUST016", relative, index, "re-export aliases are forbidden"))
     previous_export_line: int | None = None
     previous_export_visibility: str | None = None
-    previous_export_path: str | None = None
+    previous_export_key: tuple[object, ...] | None = None
     blank_since_export = False
     for index, line in enumerate(lines, 1):
         if not line.strip():
@@ -121,12 +139,13 @@ def audit_file(root: pathlib.Path, path: pathlib.Path) -> list[Violation]:
                     )
                 )
             export_path = line.split(" use ", 1)[1]
+            export_key = rustfmt_re_export_key(export_path)
             if (
                 previous_export_line is not None
                 and previous_export_visibility == visibility
                 and not blank_since_export
-                and previous_export_path is not None
+                and previous_export_key is not None
-                and export_path < previous_export_path
+                and export_key < previous_export_key
             ):
                 violations.append(
                     Violation(
@@ -138,12 +157,12 @@ def audit_file(root: pathlib.Path, path: pathlib.Path) -> list[Violation]:
                 )
             previous_export_line = index
             previous_export_visibility = visibility
-            previous_export_path = export_path
+            previous_export_key = export_key
             blank_since_export = False
             continue
         previous_export_line = None
         previous_export_visibility = None
-        previous_export_path = None
+        previous_export_key = None
         blank_since_export = False
     if path.name in {"lib.rs", "main.rs"}:
         for attribute in ("#![warn(missing_docs)]", "#![deny(unreachable_pub)]", "#![forbid(unsafe_code)]"):