refactor: use single event_type for both v1 and v2

Previously v1 and v2 used different event_type values (0x08000001 vs
0x08000002) to let verifiers distinguish formats. Now that version is
serialized on RuntimeEvent and TdxEvent via serde, a single event_type
(0x08000001) suffices — version is carried explicitly.

Changes:
- Drop DSTACK_RUNTIME_EVENT_TYPE_V2 constant
- cc_event_type() always returns DSTACK_RUNTIME_EVENT_TYPE
- Add version field to TdxEvent (serde default V1, #[codec(skip)] for scale compat)
- V2 canonical JSON now includes explicit "version": 2 field for self-describing content
- Serde skips version when V1 to keep existing JSON outputs unchanged

Scale backward compat: legacy V0 attestations contain only v1 events,
so #[codec(skip)] defaulting to V1 on decode is correct.

Author: kvinwang

cc-eventlog/src/lib.rs

@@ -4,7 +4,7 @@
 
 pub use dstack_types::EventLogVersion;
 pub use runtime_events::{
-    canonical_event_json, replay_events, RuntimeEvent, DSTACK_RUNTIME_EVENT_TYPE_V2,
+    canonical_event_json_v2, replay_events, RuntimeEvent, DSTACK_RUNTIME_EVENT_TYPE,
 };
 pub use tdx::TdxEvent;
 

cc-eventlog/src/runtime_events.rs

@@ -12,14 +12,14 @@ use std::io::Write;
 
 use ez_hash::{Hasher, Sha256, Sha384};
 
-/// The event type for dstack runtime events (v1).
+/// The event type for dstack runtime events.
 /// This code is not defined in the TCG specification.
 /// See https://trustedcomputinggroup.org/wp-content/uploads/PC-ClientSpecific_Platform_Profile_for_TPM_2p0_Systems_v51.pdf
+///
+/// V1 and V2 use the same event type; the digest format is distinguished by
+/// `EventLogVersion` (carried on `RuntimeEvent`/`TdxEvent` or inferred from
+/// the v2 canonical JSON content).
 pub const DSTACK_RUNTIME_EVENT_TYPE: u32 = 0x08000001;
-/// The event type for dstack runtime events (v2, JSON canonical content).
-/// V2 events use JCS (RFC 8785) canonical JSON as the digest input, enabling
-/// relying parties to define fine-grained trust policies on individual event claims.
-pub const DSTACK_RUNTIME_EVENT_TYPE_V2: u32 = 0x08000002;
 /// The path to the userspace TDX event log file.
 pub const RUNTIME_EVENT_LOG_FILE: &str = "/run/log/dstack/runtime_events.log";
 
@@ -112,7 +112,7 @@ impl RuntimeEvent {
     /// Compute the digest of the event.
     ///
     /// - V1: `SHA(event_type_le || ":" || event_name || ":" || payload)`
-    /// - V2: `SHA(canonical_json({"event":"...","event_type":134217730,"payload":"hex..."}))`
+    /// - V2: `SHA(canonical_json({"event":"...","event_type":134217729,"payload":"hex...","version":2}))`
     pub fn digest<H: Hasher>(&self) -> H::Output {
         match self.version {
             EventLogVersion::V1 => H::hash([
@@ -123,31 +123,30 @@ impl RuntimeEvent {
                 &self.payload,
             ]),
             EventLogVersion::V2 => {
-                let canonical =
-                    canonical_event_json(&self.event, DSTACK_RUNTIME_EVENT_TYPE_V2, &self.payload);
+                let canonical = canonical_event_json_v2(&self.event, &self.payload);
                 H::hash([canonical.as_bytes()])
             }
         }
     }
 
+    /// The event type used when extending RTMR. Always `DSTACK_RUNTIME_EVENT_TYPE`.
+    /// Version is distinguished via `EventLogVersion`, not the event type.
     pub fn cc_event_type(&self) -> u32 {
-        match self.version {
-            EventLogVersion::V1 => DSTACK_RUNTIME_EVENT_TYPE,
-            EventLogVersion::V2 => DSTACK_RUNTIME_EVENT_TYPE_V2,
-        }
+        DSTACK_RUNTIME_EVENT_TYPE
     }
 }
 
-/// Construct JCS (RFC 8785) canonical JSON for a runtime event.
+/// Construct the JCS (RFC 8785) canonical JSON used as the v2 digest input.
 ///
-/// Uses `serde_jcs` for deterministic serialization per RFC 8785,
-/// including alphabetical key ordering and canonical number/string formatting.
-/// The payload is hex-encoded for human readability.
-pub fn canonical_event_json(event: &str, event_type: u32, payload: &[u8]) -> String {
+/// The JSON includes an explicit `version: 2` field so the content is
+/// self-describing for relying parties that don't know dstack's event schema.
+/// Keys and number/string formatting are handled by `serde_jcs` per RFC 8785.
+pub fn canonical_event_json_v2(event: &str, payload: &[u8]) -> String {
     let obj = serde_json::json!({
         "event": event,
-        "event_type": event_type,
+        "event_type": DSTACK_RUNTIME_EVENT_TYPE,
         "payload": hex::encode(payload),
+        "version": 2,
     });
     serde_jcs::to_string(&obj).unwrap_or_default()
 }
@@ -195,11 +194,10 @@ mod tests {
             vec![0xab, 0xcd],
             EventLogVersion::V2,
         );
-        let canonical =
-            canonical_event_json(&event.event, DSTACK_RUNTIME_EVENT_TYPE_V2, &event.payload);
+        let canonical = canonical_event_json_v2(&event.event, &event.payload);
         assert_eq!(
             canonical,
-            r#"{"event":"compose-hash","event_type":134217730,"payload":"abcd"}"#
+            r#"{"event":"compose-hash","event_type":134217729,"payload":"abcd","version":2}"#
         );
         let digest = event.digest::<Sha384>();
         let expected = Sha384::hash([canonical.as_bytes()]);
@@ -225,8 +223,9 @@ mod tests {
 
     #[test]
     fn v2_event_type() {
+        // v2 uses the same event_type as v1 — version is carried separately
         let event = RuntimeEvent::new("test".to_string(), vec![], EventLogVersion::V2);
-        assert_eq!(event.cc_event_type(), DSTACK_RUNTIME_EVENT_TYPE_V2);
+        assert_eq!(event.cc_event_type(), DSTACK_RUNTIME_EVENT_TYPE);
     }
 
     #[test]
@@ -255,11 +254,7 @@ mod tests {
 
     #[test]
     fn canonical_json_escapes_special_chars() {
-        let canonical = canonical_event_json(
-            "event\"with\\special\nchars",
-            DSTACK_RUNTIME_EVENT_TYPE_V2,
-            &[0xff],
-        );
+        let canonical = canonical_event_json_v2("event\"with\\special\nchars", &[0xff]);
         // Verify it's valid JSON
         let parsed: serde_json::Value = serde_json::from_str(&canonical).unwrap();
         assert_eq!(

cc-eventlog/src/tcg.rs

@@ -370,6 +370,7 @@ impl TryFrom<TcgEvent> for TdxEvent {
             digest,
             event: Default::default(),
             event_payload: value.event.into(),
+            version: Default::default(),
         })
     }
 }

cc-eventlog/src/tdx.rs

@@ -3,11 +3,12 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use anyhow::Result;
+use dstack_types::EventLogVersion;
 use scale::{Decode, Encode};
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    runtime_events::{RuntimeEvent, DSTACK_RUNTIME_EVENT_TYPE, DSTACK_RUNTIME_EVENT_TYPE_V2},
+    runtime_events::{RuntimeEvent, DSTACK_RUNTIME_EVENT_TYPE},
     tcg::TcgEventLog,
 };
 
@@ -16,9 +17,9 @@ use crate::{
 /// and the raw event data. The IMR index is zero-based, unlike the TCG event log format
 /// which is one-based.
 ///
-/// As for RTMR3:
-/// - V1 (event_type 0x08000001): digest = `sha384(event_type_le || ":" || event || ":" || payload)`
-/// - V2 (event_type 0x08000002): digest = `sha384(canonical_json({"event":"...","event_type":134217730,"payload":"hex..."}))`
+/// For dstack runtime events (`event_type == DSTACK_RUNTIME_EVENT_TYPE`), the digest is:
+/// - V1: `sha384(event_type_le || ":" || event || ":" || payload)`
+/// - V2: `sha384(canonical_json({"event":"...","event_type":134217729,"payload":"hex...","version":2}))`
 #[derive(Clone, Debug, Serialize, Deserialize, Encode, Decode)]
 pub struct TdxEvent {
     /// IMR index, starts from 0
@@ -33,6 +34,17 @@ pub struct TdxEvent {
     /// Event payload
     #[serde(with = "serde_human_bytes")]
     pub event_payload: Vec<u8>,
+    /// Event log version (for dstack runtime events).
+    /// Skipped by scale codec for binary compat with legacy attestations
+    /// (which only ever contain V1 events).
+    /// Serde skips serialization when V1 so existing JSON outputs stay clean.
+    #[serde(default, skip_serializing_if = "is_v1")]
+    #[codec(skip)]
+    pub version: EventLogVersion,
+}
+
+fn is_v1(v: &EventLogVersion) -> bool {
+    matches!(v, EventLogVersion::V1)
 }
 
 impl TdxEvent {
@@ -43,6 +55,7 @@ impl TdxEvent {
             digest: vec![],
             event,
             event_payload,
+            version: EventLogVersion::default(),
         }
     }
 
@@ -56,6 +69,7 @@ impl TdxEvent {
                 digest: Vec::new(),
                 event: self.event.clone(),
                 event_payload: self.event_payload.clone(),
+                version: self.version,
             }
         } else {
             Self {
@@ -64,6 +78,7 @@ impl TdxEvent {
                 digest: self.digest.clone(),
                 event: self.event.clone(),
                 event_payload: Vec::new(),
+                version: self.version,
             }
         }
     }
@@ -77,37 +92,32 @@ impl TdxEvent {
 
     pub fn is_runtime_event(&self) -> bool {
         self.event_type == DSTACK_RUNTIME_EVENT_TYPE
-            || self.event_type == DSTACK_RUNTIME_EVENT_TYPE_V2
     }
 
     pub fn to_runtime_event(&self) -> Option<RuntimeEvent> {
         if !self.is_runtime_event() {
             return None;
         }
-        use dstack_types::EventLogVersion;
-        let version = if self.event_type == DSTACK_RUNTIME_EVENT_TYPE_V2 {
-            EventLogVersion::V2
-        } else {
-            EventLogVersion::V1
-        };
         Some(RuntimeEvent {
             event: self.event.clone(),
             payload: self.event_payload.clone(),
-            version,
+            version: self.version,
         })
     }
 }
 
 impl From<RuntimeEvent> for TdxEvent {
     fn from(value: RuntimeEvent) -> Self {
         let event_type = value.cc_event_type();
+        let version = value.version;
         let digest = value.sha384_digest().to_vec();
         TdxEvent {
             imr: 3,
             event_type,
             digest,
             event: value.event,
             event_payload: value.payload,
+            version,
         }
     }
 }