v0.4.7-pre.011

kb-pipeline-demo-scenarios/src/solana_metaplex_token_metadata_validation.rs

@@ -1,5 +1,5 @@
 // file: kb-pipeline-demo-scenarios/src/solana_metaplex_token_metadata_validation.rs
-// version: 2
+// version: 3
 
 //! Machine-readable Metaplex Token Metadata validation contract.
 
@@ -438,3 +438,162 @@ mod tests {
         }
     }
 }
+
+/// One current Metaplex operation in the closed Devnet execution matrix.
+#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MetaplexTokenMetadataDevnetExecutionOperation {
+    /// Stable instruction discriminator.
+    pub discriminator: u8,
+    /// Official instruction name.
+    pub name: std::string::String,
+    /// Stable executor operation code.
+    pub operation_code: std::string::String,
+    /// Whether the operation is deprecated.
+    pub deprecated: bool,
+    /// Prerelease responsible for the campaign.
+    pub campaign_prerelease: std::string::String,
+    /// Implementation status of the reusable runner.
+    pub runner_status: std::string::String,
+    /// Exact observed network status.
+    pub network_status: std::string::String,
+    /// Evidence required after simulation.
+    pub required_evidence: std::vec::Vec<std::string::String>,
+    /// Additional evidence required after submission.
+    pub submission_evidence: std::vec::Vec<std::string::String>,
+}
+
+/// Closed inventory of every current Metaplex operation requiring Devnet coverage.
+#[derive(Clone, Debug, Eq, PartialEq, serde::Deserialize, serde::Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MetaplexTokenMetadataDevnetExecutionMatrix {
+    /// Matrix schema version.
+    pub matrix_version: u32,
+    /// Owning prerelease.
+    pub milestone: std::string::String,
+    /// Canonical Token Metadata program ID.
+    pub program_id: std::string::String,
+    /// Ordered current operations.
+    pub operations: std::vec::Vec<crate::MetaplexTokenMetadataDevnetExecutionOperation>,
+}
+
+/// Loads and validates the closed Devnet execution matrix.
+pub fn load_metaplex_token_metadata_devnet_execution_matrix()
+-> kb_core::Result<crate::MetaplexTokenMetadataDevnetExecutionMatrix> {
+    let matrix = match serde_json::from_str::<crate::MetaplexTokenMetadataDevnetExecutionMatrix>(
+        include_str!(
+            "../../test-fixtures/contract-matrices/METAPLEX_TOKEN_METADATA_DEVNET_EXECUTION_MATRIX.json"
+        ),
+    ) {
+        std::result::Result::Ok(value) => value,
+        std::result::Result::Err(error) => {
+            return std::result::Result::Err(kb_core::Error::new(
+                "metaplex_devnet_execution_matrix_invalid_json",
+                format!("Metaplex Devnet execution matrix JSON is invalid: {error}"),
+            ));
+        },
+    };
+    if let std::result::Result::Err(error) =
+        validate_metaplex_token_metadata_devnet_execution_matrix(&matrix)
+    {
+        return std::result::Result::Err(error);
+    }
+    return std::result::Result::Ok(matrix);
+}
+
+/// Validates exact current-operation coverage and conservative network statuses.
+pub fn validate_metaplex_token_metadata_devnet_execution_matrix(
+    matrix: &crate::MetaplexTokenMetadataDevnetExecutionMatrix,
+) -> kb_core::Result<()> {
+    if matrix.matrix_version != 1
+        || matrix.milestone != "0.4.7-pre.011"
+        || matrix.program_id != kb_program_ids::METADATA_METAPLEX_TOKEN_METADATA_PROGRAM_ID
+        || matrix.operations.len() != 20
+    {
+        return std::result::Result::Err(kb_core::Error::new(
+            "metaplex_devnet_execution_matrix_contract_mismatch",
+            "Metaplex Devnet matrix must declare exactly 20 current operations for pre.011",
+        ));
+    }
+    let expected = [
+        "metadata.metaplex_token_metadata.create_escrow_account",
+        "metadata.metaplex_token_metadata.close_escrow_account",
+        "metadata.metaplex_token_metadata.transfer_out_of_escrow",
+        "metadata.metaplex_token_metadata.burn",
+        "metadata.metaplex_token_metadata.create",
+        "metadata.metaplex_token_metadata.mint",
+        "metadata.metaplex_token_metadata.delegate",
+        "metadata.metaplex_token_metadata.revoke",
+        "metadata.metaplex_token_metadata.lock",
+        "metadata.metaplex_token_metadata.unlock",
+        "metadata.metaplex_token_metadata.migrate",
+        "metadata.metaplex_token_metadata.transfer",
+        "metadata.metaplex_token_metadata.update",
+        "metadata.metaplex_token_metadata.use",
+        "metadata.metaplex_token_metadata.verify",
+        "metadata.metaplex_token_metadata.unverify",
+        "metadata.metaplex_token_metadata.collect",
+        "metadata.metaplex_token_metadata.print",
+        "metadata.metaplex_token_metadata.resize",
+        "metadata.metaplex_token_metadata.close_accounts",
+    ]
+    .into_iter()
+    .collect::<std::collections::BTreeSet<&str>>();
+    let observed = matrix
+        .operations
+        .iter()
+        .map(|operation| return operation.operation_code.as_str())
+        .collect::<std::collections::BTreeSet<&str>>();
+    if observed != expected {
+        return std::result::Result::Err(kb_core::Error::new(
+            "metaplex_devnet_execution_matrix_operation_mismatch",
+            "Metaplex Devnet matrix must cover the exact 20 current operation codes",
+        ));
+    }
+    for operation in &matrix.operations {
+        if operation.deprecated
+            || operation.required_evidence.is_empty()
+            || operation.submission_evidence.is_empty()
+            || !matches!(
+                operation.network_status.as_str(),
+                "not_run" | "simulated" | "confirmed" | "unavailable"
+            )
+        {
+            return std::result::Result::Err(kb_core::Error::new(
+                "metaplex_devnet_execution_matrix_entry_invalid",
+                "Metaplex Devnet entries must be current, evidenced and conservatively classified",
+            ));
+        }
+    }
+    return std::result::Result::Ok(());
+}
+
+#[cfg(test)]
+mod devnet_execution_matrix_tests {
+    #[test]
+    fn devnet_execution_matrix_is_closed_current_and_conservative() {
+        let result = crate::load_metaplex_token_metadata_devnet_execution_matrix();
+        assert!(result.is_ok());
+        let matrix = if let std::result::Result::Ok(value) = result {
+            value
+        } else {
+            return;
+        };
+        assert_eq!(matrix.operations.len(), 20);
+        assert_eq!(
+            matrix
+                .operations
+                .iter()
+                .filter(|operation| return operation.campaign_prerelease == "0.4.7-pre.011")
+                .count(),
+            4,
+        );
+        assert!(matrix.operations.iter().all(|operation| return !operation.deprecated));
+        assert!(
+            matrix
+                .operations
+                .iter()
+                .all(|operation| return operation.network_status == "not_run")
+        );
+    }
+}