refactor: use EventLogVersion enum instead of raw u32

Replace u32 version fields with an EventLogVersion enum to get
exhaustive match checking — adding a v3 in the future will force
all match sites to be updated at compile time.

Also removes version field from event log serialization as it's
unnecessary (verifier distinguishes v1/v2 via event_type).

Author: kvinwang

Cargo.lock

@@ -13,6 +13,7 @@ license.workspace = true
 [dependencies]
 anyhow.workspace = true
 digest = "0.10.7"
+dstack-types.workspace = true
 ez-hash.workspace = true
 fs-err.workspace = true
 hex.workspace = true

cc-eventlog/Cargo.toml

@@ -2,6 +2,7 @@
 //
 // SPDX-License-Identifier: Apache-2.0
 
+pub use dstack_types::EventLogVersion;
 pub use runtime_events::{
     canonical_event_json, replay_events, RuntimeEvent, DSTACK_RUNTIME_EVENT_TYPE_V2,
 };

cc-eventlog/src/lib.rs

@@ -3,6 +3,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use anyhow::{Context, Result};
+use dstack_types::EventLogVersion;
 use fs_err as fs;
 use scale::{Decode, Encode};
 use serde::{Deserialize, Serialize};
@@ -30,13 +31,13 @@ pub struct RuntimeEvent {
     /// Event payload
     #[serde(with = "base64")]
     pub payload: Vec<u8>,
-    /// Event log version (0 or absent = v1, 2 = v2 JSON canonical)
+    /// Event log version
     #[serde(default, skip_serializing)]
-    pub version: u32,
+    pub version: EventLogVersion,
 }
 
 impl RuntimeEvent {
-    pub fn new(event: String, payload: Vec<u8>, version: u32) -> Self {
+    pub fn new(event: String, payload: Vec<u8>, version: EventLogVersion) -> Self {
         Self {
             event,
             payload,
@@ -109,45 +110,29 @@ impl RuntimeEvent {
 
     /// Compute the digest of the event.
     ///
-    /// For v1 (version 0 or 1): `SHA(event_type_le || ":" || event_name || ":" || payload)`
-    /// For v2 (version 2): `SHA(canonical_json({"event":"...","event_type":134217730,"payload":"hex..."}))`
+    /// - V1: `SHA(event_type_le || ":" || event_name || ":" || payload)`
+    /// - V2: `SHA(canonical_json({"event":"...","event_type":134217730,"payload":"hex..."}))`
     pub fn digest<H: Hasher>(&self) -> H::Output {
-        if self.is_v2() {
-            self.digest_v2::<H>()
-        } else {
-            self.digest_v1::<H>()
+        match self.version {
+            EventLogVersion::V1 => H::hash([
+                &DSTACK_RUNTIME_EVENT_TYPE.to_ne_bytes()[..],
+                b":",
+                self.event.as_bytes(),
+                b":",
+                &self.payload,
+            ]),
+            EventLogVersion::V2 => {
+                let canonical =
+                    canonical_event_json(&self.event, DSTACK_RUNTIME_EVENT_TYPE_V2, &self.payload);
+                H::hash([canonical.as_bytes()])
+            }
         }
     }
 
-    fn digest_v1<H: Hasher>(&self) -> H::Output {
-        H::hash([
-            &DSTACK_RUNTIME_EVENT_TYPE.to_ne_bytes()[..],
-            b":",
-            self.event.as_bytes(),
-            b":",
-            &self.payload,
-        ])
-    }
-
-    /// Compute the v2 digest using JCS (RFC 8785) canonical JSON.
-    ///
-    /// The canonical JSON has keys sorted alphabetically:
-    /// `{"event":"<name>","event_type":134217730,"payload":"<hex>"}`
-    fn digest_v2<H: Hasher>(&self) -> H::Output {
-        let canonical =
-            canonical_event_json(&self.event, DSTACK_RUNTIME_EVENT_TYPE_V2, &self.payload);
-        H::hash([canonical.as_bytes()])
-    }
-
-    pub fn is_v2(&self) -> bool {
-        self.version == 2
-    }
-
     pub fn cc_event_type(&self) -> u32 {
-        if self.is_v2() {
-            DSTACK_RUNTIME_EVENT_TYPE_V2
-        } else {
-            DSTACK_RUNTIME_EVENT_TYPE
+        match self.version {
+            EventLogVersion::V1 => DSTACK_RUNTIME_EVENT_TYPE,
+            EventLogVersion::V2 => DSTACK_RUNTIME_EVENT_TYPE_V2,
         }
     }
 }
@@ -189,7 +174,11 @@ mod tests {
 
     #[test]
     fn v1_digest_unchanged() {
-        let event = RuntimeEvent::new("app-id".to_string(), vec![0xde, 0xad, 0xbe, 0xef], 1);
+        let event = RuntimeEvent::new(
+            "app-id".to_string(),
+            vec![0xde, 0xad, 0xbe, 0xef],
+            EventLogVersion::V1,
+        );
         let digest = event.digest::<Sha384>();
         let expected = Sha384::hash([
             &DSTACK_RUNTIME_EVENT_TYPE.to_ne_bytes()[..],
@@ -203,7 +192,11 @@ mod tests {
 
     #[test]
     fn v2_digest_is_canonical_json_hash() {
-        let event = RuntimeEvent::new("compose-hash".to_string(), vec![0xab, 0xcd], 2);
+        let event = RuntimeEvent::new(
+            "compose-hash".to_string(),
+            vec![0xab, 0xcd],
+            EventLogVersion::V2,
+        );
         let canonical =
             canonical_event_json(&event.event, DSTACK_RUNTIME_EVENT_TYPE_V2, &event.payload);
         assert_eq!(
@@ -217,8 +210,8 @@ mod tests {
 
     #[test]
     fn v2_digest_differs_from_v1() {
-        let v1 = RuntimeEvent::new("test".to_string(), vec![1, 2, 3], 1);
-        let v2 = RuntimeEvent::new("test".to_string(), vec![1, 2, 3], 2);
+        let v1 = RuntimeEvent::new("test".to_string(), vec![1, 2, 3], EventLogVersion::V1);
+        let v2 = RuntimeEvent::new("test".to_string(), vec![1, 2, 3], EventLogVersion::V2);
         assert_ne!(
             v1.digest::<Sha384>(),
             v2.digest::<Sha384>(),
@@ -228,29 +221,28 @@ mod tests {
 
     #[test]
     fn v1_event_type() {
-        let event = RuntimeEvent::new("test".to_string(), vec![], 1);
+        let event = RuntimeEvent::new("test".to_string(), vec![], EventLogVersion::V1);
         assert_eq!(event.cc_event_type(), DSTACK_RUNTIME_EVENT_TYPE);
     }
 
     #[test]
     fn v2_event_type() {
-        let event = RuntimeEvent::new("test".to_string(), vec![], 2);
+        let event = RuntimeEvent::new("test".to_string(), vec![], EventLogVersion::V2);
         assert_eq!(event.cc_event_type(), DSTACK_RUNTIME_EVENT_TYPE_V2);
     }
 
     #[test]
     fn deserialize_v1_without_version_field() {
         let json = r#"{"event":"app-id","payload":"AQID"}"#;
         let event: RuntimeEvent = serde_json::from_str(json).unwrap();
-        assert_eq!(event.version, 0);
-        assert!(!event.is_v2());
+        assert_eq!(event.version, EventLogVersion::V1);
         assert_eq!(event.cc_event_type(), DSTACK_RUNTIME_EVENT_TYPE);
     }
 
     #[test]
     fn serialize_omits_version() {
-        let v1 = RuntimeEvent::new("test".to_string(), vec![1], 1);
-        let v2 = RuntimeEvent::new("test".to_string(), vec![1], 2);
+        let v1 = RuntimeEvent::new("test".to_string(), vec![1], EventLogVersion::V1);
+        let v2 = RuntimeEvent::new("test".to_string(), vec![1], EventLogVersion::V2);
         let json_v1 = serde_json::to_string(&v1).unwrap();
         let json_v2 = serde_json::to_string(&v2).unwrap();
         assert!(

cc-eventlog/src/runtime_events.rs

@@ -84,10 +84,11 @@ impl TdxEvent {
         if !self.is_runtime_event() {
             return None;
         }
+        use dstack_types::EventLogVersion;
         let version = if self.event_type == DSTACK_RUNTIME_EVENT_TYPE_V2 {
-            2
+            EventLogVersion::V2
         } else {
-            0
+            EventLogVersion::V1
         };
         Some(RuntimeEvent {
             event: self.event.clone(),

cc-eventlog/src/tdx.rs

@@ -12,7 +12,7 @@ pub const TDX_QUOTE_REPORT_DATA_RANGE: std::ops::Range<usize> = 568..632;
 use std::{borrow::Cow, time::SystemTime};
 
 use anyhow::{anyhow, bail, Context, Result};
-use cc_eventlog::{RuntimeEvent, TdxEvent};
+use cc_eventlog::{EventLogVersion, RuntimeEvent, TdxEvent};
 use dcap_qvl::{
     quote::{EnclaveReport, Quote, Report, TDReport10, TDReport15},
     verify::VerifiedReport as TdxVerifiedReport,
@@ -1036,7 +1036,11 @@ impl Attestation {
         let runtime_events = if mode.is_composable() {
             RuntimeEvent::read_all().context("Failed to read runtime events")?
         } else if let Some(app_id) = app_id {
-            vec![RuntimeEvent::new("app-id".to_string(), app_id.to_vec(), 0)]
+            vec![RuntimeEvent::new(
+                "app-id".to_string(),
+                app_id.to_vec(),
+                EventLogVersion::V1,
+            )]
         } else {
             vec![]
         };

dstack-attest/src/attestation.rs

@@ -3,7 +3,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use anyhow::Context;
-use cc_eventlog::RuntimeEvent;
+use cc_eventlog::{EventLogVersion, RuntimeEvent};
 
 pub use cc_eventlog as ccel;
 pub use tdx_attest as tdx;
@@ -14,14 +14,12 @@ pub mod attestation;
 mod v1;
 
 /// Emit a runtime event that extends RTMR3 and logs the event.
-///
-/// `event_log_version`: 1 for legacy binary digest, 2 for JSON canonical digest.
 pub fn emit_runtime_event(
     event: &str,
     payload: &[u8],
-    event_log_version: u32,
+    version: EventLogVersion,
 ) -> anyhow::Result<()> {
-    let event = RuntimeEvent::new(event.to_string(), payload.to_vec(), event_log_version);
+    let event = RuntimeEvent::new(event.to_string(), payload.to_vec(), version);
 
     let mode = AttestationMode::detect()?;
 

dstack-attest/src/lib.rs

@@ -9,6 +9,45 @@ use serde::{Deserialize, Serialize};
 use serde_human_bytes as hex_bytes;
 use size_parser::human_size;
 
+/// Event log version controlling the digest format.
+///
+/// Using an enum ensures exhaustive matching — adding a new version
+/// forces all match sites to be updated.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Encode, Decode)]
+pub enum EventLogVersion {
+    /// Legacy binary digest: `SHA(event_type_le || ":" || name || ":" || payload)`
+    #[default]
+    V1,
+    /// JSON canonical digest (JCS RFC 8785):
+    /// `SHA({"event":"...","event_type":134217730,"payload":"hex..."})`
+    V2,
+}
+
+impl EventLogVersion {
+    pub fn from_u32(v: u32) -> Self {
+        match v {
+            2 => EventLogVersion::V2,
+            _ => EventLogVersion::V1,
+        }
+    }
+}
+
+impl Serialize for EventLogVersion {
+    fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        match self {
+            EventLogVersion::V1 => serializer.serialize_u32(1),
+            EventLogVersion::V2 => serializer.serialize_u32(2),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for EventLogVersion {
+    fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        let v = u32::deserialize(deserializer)?;
+        Ok(EventLogVersion::from_u32(v))
+    }
+}
+
 #[derive(Deserialize, Serialize, Debug, Clone)]
 pub struct AppCompose {
     pub manifest_version: u32,
@@ -45,18 +84,14 @@ pub struct AppCompose {
     pub storage_fs: Option<String>,
     #[serde(default, with = "human_size")]
     pub swap_size: u64,
-    #[serde(default = "default_event_log_version")]
-    pub event_log_version: u32,
+    #[serde(default)]
+    pub event_log_version: EventLogVersion,
 }
 
 fn default_true() -> bool {
     true
 }
 
-fn default_event_log_version() -> u32 {
-    1
-}
-
 fn deserialize_gateway_enabled<'de, D>(deserializer: D) -> Result<bool, D::Error>
 where
     D: serde::Deserializer<'de>,

dstack-types/src/lib.rs

@@ -228,8 +228,8 @@ fn hex_decode(hex_str: &str) -> Result<Vec<u8>> {
 
 fn cmd_extend(extend_args: ExtendArgs) -> Result<()> {
     let payload = hex_decode(&extend_args.payload).context("Failed to decode payload")?;
-    emit_runtime_event(&extend_args.event, &payload, extend_args.event_log_version)
-        .context("Failed to extend RTMR")
+    let version = dstack_types::EventLogVersion::from_u32(extend_args.event_log_version);
+    emit_runtime_event(&extend_args.event, &payload, version).context("Failed to extend RTMR")
 }
 
 fn cmd_rand(rand_args: RandArgs) -> Result<()> {

dstack-util/src/main.rs

@@ -20,7 +20,7 @@ use dstack_types::{
         APP_COMPOSE, APP_KEYS, DECRYPTED_ENV, DECRYPTED_ENV_JSON, ENCRYPTED_ENV,
         HOST_SHARED_DIR_NAME, HOST_SHARED_DISK_LABEL, INSTANCE_INFO, SYS_CONFIG, USER_CONFIG,
     },
-    KeyProvider, KeyProviderInfo,
+    EventLogVersion, KeyProvider, KeyProviderInfo,
 };
 use fs_err as fs;
 use luks2::{
@@ -688,7 +688,10 @@ fn truncate(s: &[u8], len: usize) -> &[u8] {
     }
 }
 
-fn emit_key_provider_info(provider_info: &KeyProviderInfo, event_log_version: u32) -> Result<()> {
+fn emit_key_provider_info(
+    provider_info: &KeyProviderInfo,
+    event_log_version: EventLogVersion,
+) -> Result<()> {
     info!("Key provider info: {provider_info:?}");
     let provider_info_json = serde_json::to_vec(&provider_info)?;
     emit_runtime_event("key-provider", &provider_info_json, event_log_version)?;