diff --git a/CHANGELOG.md b/CHANGELOG.md index 9c50060..532a109 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,8 +1,15 @@ - + # 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`. diff --git a/README.md b/README.md index 76db7c6..b26030b 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,5 @@ - + # 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`. diff --git a/ROADMAP.md b/ROADMAP.md index 74fe740..bfc963e 100644 --- a/ROADMAP.md +++ b/ROADMAP.md @@ -1,5 +1,5 @@ - + # 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. -- [ ] Vérifier puis restaurer les squelettes des familles de matérialisation encore vides. +- [x] Valider le nouveau test unitaire, les 130 Program IDs, Clippy et le workspace avec Cargo sur la machine de développement. +- [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. diff --git a/RULES.md b/RULES.md index efbd2ba..95d1dc4 100644 --- a/RULES.md +++ b/RULES.md @@ -1,5 +1,5 @@ - + # 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. diff --git a/RUST_RULES.md b/RUST_RULES.md index fc19698..26c8e40 100644 --- a/RUST_RULES.md +++ b/RUST_RULES.md @@ -1,5 +1,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 diff --git a/kb-lib/src/lib.rs b/kb-lib/src/lib.rs index 1cd4e62..7a23cea 100644 --- a/kb-lib/src/lib.rs +++ b/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. diff --git a/kb-lib/src/materializer.rs b/kb-lib/src/materializer.rs index e0b76b5..0d2265d 100644 --- a/kb-lib/src/materializer.rs +++ b/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()); + } + } +} diff --git a/kb-lib/src/materializer/bridge.rs b/kb-lib/src/materializer/bridge.rs index 9ff6fc8..2234b44 100644 --- a/kb-lib/src/materializer/bridge.rs +++ b/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; diff --git a/kb-lib/src/materializer/bridge/core.rs b/kb-lib/src/materializer/bridge/core.rs index 0389bee..4755931 100644 --- a/kb-lib/src/materializer/bridge/core.rs +++ b/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> { + 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(); + } +} diff --git a/kb-lib/src/materializer/governance.rs b/kb-lib/src/materializer/governance.rs index d586494..fc4efc0 100644 --- a/kb-lib/src/materializer/governance.rs +++ b/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; diff --git a/kb-lib/src/materializer/governance/core.rs b/kb-lib/src/materializer/governance/core.rs index d4d67bf..c44f295 100644 --- a/kb-lib/src/materializer/governance/core.rs +++ b/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> { + 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(); + } +} diff --git a/kb-lib/src/materializer/lending.rs b/kb-lib/src/materializer/lending.rs index 7c00cdc..efd455f 100644 --- a/kb-lib/src/materializer/lending.rs +++ b/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; diff --git a/kb-lib/src/materializer/lending/core.rs b/kb-lib/src/materializer/lending/core.rs index f88ba17..19a6a93 100644 --- a/kb-lib/src/materializer/lending/core.rs +++ b/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> { + 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(); + } +} diff --git a/kb-lib/src/materializer/liquidity.rs b/kb-lib/src/materializer/liquidity.rs index 38e5801..7cb09e2 100644 --- a/kb-lib/src/materializer/liquidity.rs +++ b/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; diff --git a/kb-lib/src/materializer/liquidity/core.rs b/kb-lib/src/materializer/liquidity/core.rs index 2f66366..37a9f2b 100644 --- a/kb-lib/src/materializer/liquidity/core.rs +++ b/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> { + 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(); + } +} diff --git a/kb-lib/src/materializer/nft.rs b/kb-lib/src/materializer/nft.rs index 2d615eb..b926ad6 100644 --- a/kb-lib/src/materializer/nft.rs +++ b/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; diff --git a/kb-lib/src/materializer/nft/core.rs b/kb-lib/src/materializer/nft/core.rs index ed017f5..e3a08d5 100644 --- a/kb-lib/src/materializer/nft/core.rs +++ b/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> { + 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(); + } +} diff --git a/kb-lib/src/materializer/oracle.rs b/kb-lib/src/materializer/oracle.rs index b0d18a8..9a58713 100644 --- a/kb-lib/src/materializer/oracle.rs +++ b/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; diff --git a/kb-lib/src/materializer/oracle/core.rs b/kb-lib/src/materializer/oracle/core.rs index 0967b2a..31ed145 100644 --- a/kb-lib/src/materializer/oracle/core.rs +++ b/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> { + 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(); + } +} diff --git a/kb-lib/src/materializer/orderbook.rs b/kb-lib/src/materializer/orderbook.rs index 6fc67c4..633d315 100644 --- a/kb-lib/src/materializer/orderbook.rs +++ b/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; diff --git a/kb-lib/src/materializer/orderbook/core.rs b/kb-lib/src/materializer/orderbook/core.rs index e40ce54..c9a974e 100644 --- a/kb-lib/src/materializer/orderbook/core.rs +++ b/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> { + 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(); + } +} diff --git a/kb-lib/src/materializer/perpetuals.rs b/kb-lib/src/materializer/perpetuals.rs index f1000da..7adbbe6 100644 --- a/kb-lib/src/materializer/perpetuals.rs +++ b/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; diff --git a/kb-lib/src/materializer/perpetuals/core.rs b/kb-lib/src/materializer/perpetuals/core.rs index 90ee42d..6a76bed 100644 --- a/kb-lib/src/materializer/perpetuals/core.rs +++ b/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> { + 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(); + } +} diff --git a/kb-lib/src/materializer/pool.rs b/kb-lib/src/materializer/pool.rs index b561acf..a9623e3 100644 --- a/kb-lib/src/materializer/pool.rs +++ b/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; diff --git a/kb-lib/src/materializer/pool/state.rs b/kb-lib/src/materializer/pool/state.rs index 44b7b13..3eca223 100644 --- a/kb-lib/src/materializer/pool/state.rs +++ b/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> { + 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(); + } +} diff --git a/kb-lib/src/materializer/rewards.rs b/kb-lib/src/materializer/rewards.rs index 91fddba..99e0a9c 100644 --- a/kb-lib/src/materializer/rewards.rs +++ b/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; diff --git a/kb-lib/src/materializer/rewards/core.rs b/kb-lib/src/materializer/rewards/core.rs index 7fbfb16..722ed29 100644 --- a/kb-lib/src/materializer/rewards/core.rs +++ b/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> { + 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(); + } +} diff --git a/kb-lib/src/materializer/routing.rs b/kb-lib/src/materializer/routing.rs index eea8bb9..7312e48 100644 --- a/kb-lib/src/materializer/routing.rs +++ b/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; diff --git a/kb-lib/src/materializer/routing/core.rs b/kb-lib/src/materializer/routing/core.rs index caa8c92..0eb0692 100644 --- a/kb-lib/src/materializer/routing/core.rs +++ b/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> { + 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(); + } +} diff --git a/kb-lib/src/materializer/token.rs b/kb-lib/src/materializer/token.rs index 74438e7..3b3a8a1 100644 --- a/kb-lib/src/materializer/token.rs +++ b/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; diff --git a/kb-lib/src/materializer/token/metadata_risk.rs b/kb-lib/src/materializer/token/metadata_risk.rs index 5a10a7f..c104c20 100644 --- a/kb-lib/src/materializer/token/metadata_risk.rs +++ b/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> { + 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(); + } +} diff --git a/kb-lib/src/materializer/trades.rs b/kb-lib/src/materializer/trades.rs index bff5e48..1c8b57e 100644 --- a/kb-lib/src/materializer/trades.rs +++ b/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; diff --git a/kb-lib/src/materializer/trades/core.rs b/kb-lib/src/materializer/trades/core.rs index 2ebf10b..67161dd 100644 --- a/kb-lib/src/materializer/trades/core.rs +++ b/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> { + 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(); + } +} diff --git a/kb-lib/src/materializer/vault.rs b/kb-lib/src/materializer/vault.rs index b8347ef..8955367 100644 --- a/kb-lib/src/materializer/vault.rs +++ b/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; diff --git a/kb-lib/src/materializer/vault/core.rs b/kb-lib/src/materializer/vault/core.rs index 37399ce..eb906f5 100644 --- a/kb-lib/src/materializer/vault/core.rs +++ b/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> { + 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(); + } +} diff --git a/kb-lib/tests/external_materializer_api.rs b/kb-lib/tests/external_materializer_api.rs index 1e06a09..017ac08 100644 --- a/kb-lib/tests/external_materializer_api.rs +++ b/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::(); + assert_event_materializer::(); assert_event_materializer::(); assert_event_materializer::(); + assert_event_materializer::(); + assert_event_materializer::(); assert_event_materializer::(); + assert_event_materializer::(); + assert_event_materializer::(); + assert_event_materializer::(); + assert_event_materializer::(); + assert_event_materializer::(); + assert_event_materializer::(); + assert_event_materializer::(); assert_event_materializer::(); + assert_event_materializer::(); assert_event_materializer::(); assert_event_materializer::(); + assert_event_materializer::(); + assert_event_materializer::(); assert_event_materializer::(); + assert_event_materializer::(); + assert_legacy_materializer::(); + assert_legacy_materializer::(); + assert_legacy_materializer::(); + assert_legacy_materializer::(); assert_legacy_materializer::(); + assert_legacy_materializer::(); + assert_legacy_materializer::(); + assert_legacy_materializer::(); + assert_legacy_materializer::(); + assert_legacy_materializer::(); + assert_legacy_materializer::(); + assert_legacy_materializer::(); + assert_legacy_materializer::(); + assert_legacy_materializer::(); + assert_legacy_materializer::(); 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; diff --git a/scripts/audit_khadhroony_workspace_rules.py b/scripts/audit_khadhroony_workspace_rules.py index 8ffdcd6..9f7a65c 100755 --- a/scripts/audit_khadhroony_workspace_rules.py +++ b/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) diff --git a/scripts/audit_rust_general_rules.py b/scripts/audit_rust_general_rules.py index c113e14..679f4af 100755 --- a/scripts/audit_rust_general_rules.py +++ b/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 export_path < previous_export_path + and previous_export_key is not None + 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)]"):