v0.4.7-pre.009

kb-app-demo-desktop/src/demo_execution_metadata.rs

@@ -0,0 +1,192 @@
+// file: kb-app-demo-desktop/src/demo_execution_metadata.rs
+// version: 2
+
+//! Thin desktop adapters for metadata execution demo scenarios.
+
+/// UI-safe Metaplex scenario row.
+#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize, ts_rs::TS)]
+#[serde(rename_all = "camelCase")]
+#[ts(
+    export,
+    export_to = "../frontend/ts/bindings/kb_app_demo_desktop/demo_execution_metadata/DemoExecutionMetadataScenarioPayload.ts"
+)]
+pub(crate) struct DemoExecutionMetadataScenarioPayload {
+    /// Stable scenario identifier.
+    pub id: std::string::String,
+    /// Stable asset-family code.
+    pub asset_family: std::string::String,
+    /// Stable execution-mode code.
+    pub mode: std::string::String,
+    /// Ordered operation codes.
+    pub operation_codes: std::vec::Vec<std::string::String>,
+    /// Whether a collection account is required.
+    pub requires_collection: bool,
+    /// Whether programmable authorization rules are required.
+    pub requires_programmable_rules: bool,
+    /// Whether postconditions are mandatory.
+    pub requires_postcondition: bool,
+    /// Current validation status from the canonical matrix.
+    pub validation_status: std::string::String,
+    /// Required evidence kinds.
+    pub required_evidence: std::vec::Vec<std::string::String>,
+}
+
+/// Returns the canonical Metaplex scenario inventory for the desktop panel.
+pub(crate) fn demo_execution_metadata_scenarios() -> std::result::Result<
+    std::vec::Vec<crate::DemoExecutionMetadataScenarioPayload>,
+    std::string::String,
+> {
+    let matrix = match kb_pipeline_demo_scenarios::load_metaplex_token_metadata_validation_matrix()
+    {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => return std::result::Result::Err(error.to_string()),
+    };
+    let statuses = matrix
+        .scenarios
+        .into_iter()
+        .map(|scenario| return (scenario.id, (scenario.status, scenario.required_evidence)))
+        .collect::<std::collections::BTreeMap<
+            std::string::String,
+            (
+                kb_pipeline_demo_scenarios::MetaplexTokenMetadataValidationStatus,
+                std::vec::Vec<std::string::String>,
+            ),
+        >>();
+    let mut payloads = std::vec::Vec::new();
+    for scenario in kb_pipeline_demo_scenarios::metaplex_token_metadata_synthetic_scenarios()
+        .into_iter()
+        .chain(kb_pipeline_demo_scenarios::metaplex_token_metadata_devnet_scenarios())
+    {
+        let status = statuses.get(scenario.id.as_str());
+        let validation_status = match status {
+            std::option::Option::Some((value, _)) => validation_status_code(*value),
+            std::option::Option::None => "not_run".to_string(),
+        };
+        let required_evidence = match status {
+            std::option::Option::Some((_, evidence)) => evidence.clone(),
+            std::option::Option::None => std::vec::Vec::new(),
+        };
+        payloads.push(crate::DemoExecutionMetadataScenarioPayload {
+            id: scenario.id,
+            asset_family: asset_family_code(scenario.asset_family),
+            mode: scenario_mode_code(scenario.mode),
+            operation_codes: scenario.operation_codes,
+            requires_collection: scenario.requires_collection,
+            requires_programmable_rules: scenario.requires_programmable_rules,
+            requires_postcondition: scenario.requires_postcondition,
+            validation_status,
+            required_evidence,
+        });
+    }
+    return std::result::Result::Ok(payloads);
+}
+
+fn asset_family_code(
+    value: kb_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily,
+) -> std::string::String {
+    return match value {
+        kb_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily::Nft => "nft".to_string(),
+        kb_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily::Sft => "sft".to_string(),
+        kb_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily::Fungible => {
+            "fungible".to_string()
+        },
+        kb_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily::Collection => {
+            "collection".to_string()
+        },
+        kb_pipeline_demo_scenarios::MetaplexTokenMetadataAssetFamily::ProgrammableNft => {
+            "programmable_nft".to_string()
+        },
+    };
+}
+
+fn scenario_mode_code(
+    value: kb_pipeline_demo_scenarios::MetaplexTokenMetadataScenarioMode,
+) -> std::string::String {
+    return match value {
+        kb_pipeline_demo_scenarios::MetaplexTokenMetadataScenarioMode::Synthetic => {
+            "synthetic".to_string()
+        },
+        kb_pipeline_demo_scenarios::MetaplexTokenMetadataScenarioMode::NetworkSimulation => {
+            "network_simulation".to_string()
+        },
+        kb_pipeline_demo_scenarios::MetaplexTokenMetadataScenarioMode::NetworkSubmission => {
+            "network_submission".to_string()
+        },
+    };
+}
+
+fn validation_status_code(
+    value: kb_pipeline_demo_scenarios::MetaplexTokenMetadataValidationStatus,
+) -> std::string::String {
+    return match value {
+        kb_pipeline_demo_scenarios::MetaplexTokenMetadataValidationStatus::NotRun => {
+            "not_run".to_string()
+        },
+        kb_pipeline_demo_scenarios::MetaplexTokenMetadataValidationStatus::SyntheticValidated => {
+            "synthetic_validated".to_string()
+        },
+        kb_pipeline_demo_scenarios::MetaplexTokenMetadataValidationStatus::Simulated => {
+            "simulated".to_string()
+        },
+        kb_pipeline_demo_scenarios::MetaplexTokenMetadataValidationStatus::Submitted => {
+            "submitted".to_string()
+        },
+        kb_pipeline_demo_scenarios::MetaplexTokenMetadataValidationStatus::Confirmed => {
+            "confirmed".to_string()
+        },
+        kb_pipeline_demo_scenarios::MetaplexTokenMetadataValidationStatus::Unavailable => {
+            "unavailable".to_string()
+        },
+        kb_pipeline_demo_scenarios::MetaplexTokenMetadataValidationStatus::Failed => {
+            "failed".to_string()
+        },
+    };
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn desktop_inventory_matches_reusable_scenarios_and_matrix() {
+        let payloads = match crate::demo_execution_metadata_scenarios() {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => {
+                assert_eq!(std::option::Option::Some(error), std::option::Option::None);
+                return;
+            },
+        };
+        assert_eq!(payloads.len(), 10);
+        assert!(payloads.iter().all(|payload| return !payload.operation_codes.is_empty()));
+        assert!(payloads.iter().all(|payload| return payload.requires_postcondition));
+        assert!(
+            payloads
+                .iter()
+                .all(|payload| return payload.validation_status != "missing_from_matrix")
+        );
+        assert_eq!(
+            payloads
+                .iter()
+                .filter(|payload| return payload.mode == "network_simulation")
+                .count(),
+            5
+        );
+    }
+
+    #[test]
+    fn programmable_and_collection_requirements_remain_explicit() {
+        let payloads = match crate::demo_execution_metadata_scenarios() {
+            std::result::Result::Ok(value) => value,
+            std::result::Result::Err(error) => {
+                assert_eq!(std::option::Option::Some(error), std::option::Option::None);
+                return;
+            },
+        };
+        assert_eq!(payloads.iter().filter(|payload| return payload.requires_collection).count(), 2);
+        assert_eq!(
+            payloads
+                .iter()
+                .filter(|payload| return payload.requires_programmable_rules)
+                .count(),
+            2
+        );
+    }
+}