sim-rs: fix indefinite length map encoding

SupernaviX · SupernaviX · commit 2692d24b16ad · 2025-04-09T10:44:21.000-04:00
diff --git a/sim-rs/sim-cli/src/events.rs b/sim-rs/sim-cli/src/events.rs
@@ -258,6 +258,7 @@ impl EventMonitor {
                     header_bytes,
                     total_bytes,
                     transactions,
+                    ..
                 } => {
                     generated_ibs += 1;
                     if transactions.is_empty() {
diff --git a/sim-rs/sim-core/src/events.rs b/sim-rs/sim-core/src/events.rs
@@ -93,83 +93,111 @@ pub enum Event {
         recipient: Node,
     },
     RBLotteryWon {
-        #[serde(flatten)]
         id: BlockId<Node>,
+        slot: u64,
+        producer: Node,
     },
     RBGenerated {
-        #[serde(flatten)]
         id: BlockId<Node>,
+        slot: u64,
+        producer: Node,
         vrf: u64,
         parent: Option<BlockId<Node>>,
         header_bytes: u64,
         endorsement: Option<Endorsement<Node>>,
         transactions: Vec<TransactionId>,
     },
     RBSent {
-        #[serde(flatten)]
         id: BlockId<Node>,
+        slot: u64,
+        producer: Node,
         sender: Node,
         recipient: Node,
     },
     RBReceived {
-        #[serde(flatten)]
         id: BlockId<Node>,
+        slot: u64,
+        producer: Node,
         sender: Node,
         recipient: Node,
     },
     IBLotteryWon {
-        #[serde(flatten)]
         id: InputBlockId<Node>,
+        slot: u64,
+        pipeline: u64,
+        producer: Node,
+        index: u64,
     },
     IBGenerated {
-        #[serde(flatten)]
         id: InputBlockId<Node>,
+        slot: u64,
+        pipeline: u64,
+        producer: Node,
+        index: u64,
         header_bytes: u64,
         total_bytes: u64,
         transactions: Vec<TransactionId>,
     },
     IBSent {
-        #[serde(flatten)]
         id: InputBlockId<Node>,
+        slot: u64,
+        pipeline: u64,
+        producer: Node,
+        index: u64,
         sender: Node,
         recipient: Node,
     },
     IBReceived {
-        #[serde(flatten)]
         id: InputBlockId<Node>,
+        slot: u64,
+        pipeline: u64,
+        producer: Node,
+        index: u64,
         sender: Node,
         recipient: Node,
     },
     EBLotteryWon {
-        #[serde(flatten)]
         id: EndorserBlockId<Node>,
+        slot: u64,
+        pipeline: u64,
+        producer: Node,
     },
     EBGenerated {
-        #[serde(flatten)]
         id: EndorserBlockId<Node>,
+        slot: u64,
+        pipeline: u64,
+        producer: Node,
         bytes: u64,
         input_blocks: Vec<InputBlockId<Node>>,
         endorser_blocks: Vec<EndorserBlockId<Node>>,
     },
     EBSent {
-        #[serde(flatten)]
         id: EndorserBlockId<Node>,
+        slot: u64,
+        pipeline: u64,
+        producer: Node,
         sender: Node,
         recipient: Node,
     },
     EBReceived {
-        #[serde(flatten)]
         id: EndorserBlockId<Node>,
+        slot: u64,
+        pipeline: u64,
+        producer: Node,
         sender: Node,
         recipient: Node,
     },
     VTLotteryWon {
-        #[serde(flatten)]
         id: VoteBundleId<Node>,
+        slot: u64,
+        pipeline: u64,
+        producer: Node,
     },
     VTBundleGenerated {
-        #[serde(flatten)]
         id: VoteBundleId<Node>,
+        slot: u64,
+        pipeline: u64,
+        producer: Node,
         bytes: u64,
         votes: Votes<Node>,
     },
@@ -181,14 +209,18 @@ pub enum Event {
         reason: NoVoteReason,
     },
     VTBundleSent {
-        #[serde(flatten)]
         id: VoteBundleId<Node>,
+        slot: u64,
+        pipeline: u64,
+        producer: Node,
         sender: Node,
         recipient: Node,
     },
     VTBundleReceived {
-        #[serde(flatten)]
         id: VoteBundleId<Node>,
+        slot: u64,
+        pipeline: u64,
+        producer: Node,
         sender: Node,
         recipient: Node,
     },
@@ -273,12 +305,16 @@ impl EventTracker {
     pub fn track_praos_block_lottery_won(&self, block: &Block) {
         self.send(Event::RBLotteryWon {
             id: self.to_block(block.id),
+            slot: block.id.slot,
+            producer: self.to_node(block.id.producer),
         });
     }
 
     pub fn track_praos_block_generated(&self, block: &Block) {
         self.send(Event::RBGenerated {
             id: self.to_block(block.id),
+            slot: block.id.slot,
+            producer: self.to_node(block.id.producer),
             vrf: block.vrf,
             parent: block.parent.map(|id| self.to_block(id)),
             header_bytes: block.header_bytes,
@@ -298,6 +334,8 @@ impl EventTracker {
     pub fn track_praos_block_sent(&self, block: &Block, sender: NodeId, recipient: NodeId) {
         self.send(Event::RBSent {
             id: self.to_block(block.id),
+            slot: block.id.slot,
+            producer: self.to_node(block.id.producer),
             sender: self.to_node(sender),
             recipient: self.to_node(recipient),
         });
@@ -306,6 +344,8 @@ impl EventTracker {
     pub fn track_praos_block_received(&self, block: &Block, sender: NodeId, recipient: NodeId) {
         self.send(Event::RBReceived {
             id: self.to_block(block.id),
+            slot: block.id.slot,
+            producer: self.to_node(block.id.producer),
             sender: self.to_node(sender),
             recipient: self.to_node(recipient),
         });
@@ -338,12 +378,20 @@ impl EventTracker {
     pub fn track_ib_lottery_won(&self, id: InputBlockId) {
         self.send(Event::IBLotteryWon {
             id: self.to_input_block(id),
+            slot: id.slot,
+            pipeline: id.pipeline,
+            producer: self.to_node(id.producer),
+            index: id.index,
         });
     }
 
     pub fn track_ib_generated(&self, block: &crate::model::InputBlock) {
         self.send(Event::IBGenerated {
             id: self.to_input_block(block.header.id),
+            slot: block.header.id.slot,
+            pipeline: block.header.id.pipeline,
+            producer: self.to_node(block.header.id.producer),
+            index: block.header.id.index,
             header_bytes: block.header.bytes,
             total_bytes: block.header.bytes
                 + block.transactions.iter().map(|tx| tx.bytes).sum::<u64>(),
@@ -354,6 +402,10 @@ impl EventTracker {
     pub fn track_ib_sent(&self, id: InputBlockId, sender: NodeId, recipient: NodeId) {
         self.send(Event::IBSent {
             id: self.to_input_block(id),
+            slot: id.slot,
+            pipeline: id.pipeline,
+            producer: self.to_node(id.producer),
+            index: id.index,
             sender: self.to_node(sender),
             recipient: self.to_node(recipient),
         });
@@ -362,6 +414,10 @@ impl EventTracker {
     pub fn track_ib_received(&self, id: InputBlockId, sender: NodeId, recipient: NodeId) {
         self.send(Event::IBReceived {
             id: self.to_input_block(id),
+            slot: id.slot,
+            pipeline: id.pipeline,
+            producer: self.to_node(id.producer),
+            index: id.index,
             sender: self.to_node(sender),
             recipient: self.to_node(recipient),
         });
@@ -370,12 +426,18 @@ impl EventTracker {
     pub fn track_eb_lottery_won(&self, id: EndorserBlockId) {
         self.send(Event::EBLotteryWon {
             id: self.to_endorser_block(id),
+            slot: id.slot,
+            pipeline: id.pipeline,
+            producer: self.to_node(id.producer),
         });
     }
 
     pub fn track_eb_generated(&self, block: &crate::model::EndorserBlock) {
         self.send(Event::EBGenerated {
             id: self.to_endorser_block(block.id()),
+            slot: block.slot,
+            pipeline: block.pipeline,
+            producer: self.to_node(block.producer),
             bytes: block.bytes,
             input_blocks: block
                 .ibs
@@ -393,6 +455,9 @@ impl EventTracker {
     pub fn track_eb_sent(&self, id: EndorserBlockId, sender: NodeId, recipient: NodeId) {
         self.send(Event::EBSent {
             id: self.to_endorser_block(id),
+            slot: id.slot,
+            pipeline: id.pipeline,
+            producer: self.to_node(id.producer),
             sender: self.to_node(sender),
             recipient: self.to_node(recipient),
         });
@@ -401,6 +466,9 @@ impl EventTracker {
     pub fn track_eb_received(&self, id: EndorserBlockId, sender: NodeId, recipient: NodeId) {
         self.send(Event::EBReceived {
             id: self.to_endorser_block(id),
+            slot: id.slot,
+            pipeline: id.pipeline,
+            producer: self.to_node(id.producer),
             sender: self.to_node(sender),
             recipient: self.to_node(recipient),
         });
@@ -409,12 +477,18 @@ impl EventTracker {
     pub fn track_vote_lottery_won(&self, id: VoteBundleId) {
         self.send(Event::VTLotteryWon {
             id: self.to_vote_bundle(id),
+            slot: id.slot,
+            pipeline: id.pipeline,
+            producer: self.to_node(id.producer),
         });
     }
 
     pub fn track_votes_generated(&self, votes: &VoteBundle) {
         self.send(Event::VTBundleGenerated {
             id: self.to_vote_bundle(votes.id),
+            slot: votes.id.slot,
+            pipeline: votes.id.pipeline,
+            producer: self.to_node(votes.id.producer),
             bytes: votes.bytes,
             votes: Votes(
                 votes
@@ -446,6 +520,9 @@ impl EventTracker {
     pub fn track_votes_sent(&self, votes: &VoteBundle, sender: NodeId, recipient: NodeId) {
         self.send(Event::VTBundleSent {
             id: self.to_vote_bundle(votes.id),
+            slot: votes.id.slot,
+            pipeline: votes.id.pipeline,
+            producer: self.to_node(votes.id.producer),
             sender: self.to_node(sender),
             recipient: self.to_node(recipient),
         });
@@ -454,6 +531,9 @@ impl EventTracker {
     pub fn track_votes_received(&self, votes: &VoteBundle, sender: NodeId, recipient: NodeId) {
         self.send(Event::VTBundleReceived {
             id: self.to_vote_bundle(votes.id),
+            slot: votes.id.slot,
+            pipeline: votes.id.pipeline,
+            producer: self.to_node(votes.id.producer),
             sender: self.to_node(sender),
             recipient: self.to_node(recipient),
         });
diff --git a/sim-rs/sim-core/src/model.rs b/sim-rs/sim-core/src/model.rs
@@ -1,7 +1,7 @@
 use std::{collections::BTreeMap, fmt::Display, sync::Arc};
 
 use crate::{clock::Timestamp, config::NodeId};
-use serde::{ser::SerializeStruct, Serialize};
+use serde::Serialize;
 
 macro_rules! id_wrapper {
     ($outer:ident, $inner:ty) => {
@@ -53,16 +53,12 @@ impl<Node: Display> Display for BlockId<Node> {
     }
 }
 
-impl<Node: Display + Serialize> Serialize for BlockId<Node> {
+impl<Node: Display> Serialize for BlockId<Node> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: serde::Serializer,
     {
-        let mut obj = serializer.serialize_struct("BlockId", 3)?;
-        obj.serialize_field("id", &self.to_string())?;
-        obj.serialize_field("slot", &self.slot)?;
-        obj.serialize_field("producer", &self.producer)?;
-        obj.end()
+        serializer.serialize_str(&self.to_string())
     }
 }
 
@@ -116,18 +112,12 @@ impl<Node: Display> Display for InputBlockId<Node> {
     }
 }
 
-impl<Node: Display + Serialize> Serialize for InputBlockId<Node> {
+impl<Node: Display> Serialize for InputBlockId<Node> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: serde::Serializer,
     {
-        let mut obj = serializer.serialize_struct("InputBlockId", 5)?;
-        obj.serialize_field("id", &self.to_string())?;
-        obj.serialize_field("slot", &self.slot)?;
-        obj.serialize_field("pipeline", &self.pipeline)?;
-        obj.serialize_field("producer", &self.producer)?;
-        obj.serialize_field("index", &self.index)?;
-        obj.end()
+        serializer.serialize_str(&self.to_string())
     }
 }
 
@@ -161,17 +151,12 @@ impl<Node: Display> Display for EndorserBlockId<Node> {
         f.write_fmt(format_args!("{}-{}", self.slot, self.producer))
     }
 }
-impl<Node: Display + Serialize> Serialize for EndorserBlockId<Node> {
+impl<Node: Display> Serialize for EndorserBlockId<Node> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: serde::Serializer,
     {
-        let mut obj = serializer.serialize_struct("EndorserBlockId", 4)?;
-        obj.serialize_field("id", &self.to_string())?;
-        obj.serialize_field("slot", &self.slot)?;
-        obj.serialize_field("pipeline", &self.pipeline)?;
-        obj.serialize_field("producer", &self.producer)?;
-        obj.end()
+        serializer.serialize_str(&self.to_string())
     }
 }
 
@@ -206,17 +191,12 @@ impl<Node: Display> Display for VoteBundleId<Node> {
         f.write_fmt(format_args!("{}-{}", self.slot, self.producer))
     }
 }
-impl<Node: Display + Serialize> Serialize for VoteBundleId<Node> {
+impl<Node: Display> Serialize for VoteBundleId<Node> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: serde::Serializer,
     {
-        let mut obj = serializer.serialize_struct("VoteBundleId", 4)?;
-        obj.serialize_field("id", &self.to_string())?;
-        obj.serialize_field("slot", &self.slot)?;
-        obj.serialize_field("pipeline", &self.pipeline)?;
-        obj.serialize_field("producer", &self.producer)?;
-        obj.end()
+        serializer.serialize_str(&self.to_string())
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`use std::{collections::BTreeMap, fmt::Display, sync::Arc};`
`2`	`2`
`3`	`3`	`use crate::{clock::Timestamp, config::NodeId};`
`4`		`-use serde::{ser::SerializeStruct, Serialize};`
	`4`	`+use serde::Serialize;`
`5`	`5`
`6`	`6`	`macro_rules! id_wrapper {`
`7`	`7`	`($outer:ident, $inner:ty) => {`
`@@ -53,16 +53,12 @@ impl<Node: Display> Display for BlockId<Node> {`
`53`	`53`	`}`
`54`	`54`	`}`
`55`	`55`
`56`		`-impl<Node: Display + Serialize> Serialize for BlockId<Node> {`
	`56`	`+impl<Node: Display> Serialize for BlockId<Node> {`
`57`	`57`	`fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>`
`58`	`58`	`where`
`59`	`59`	`S: serde::Serializer,`
`60`	`60`	`{`
`61`		`- let mut obj = serializer.serialize_struct("BlockId", 3)?;`
`62`		`- obj.serialize_field("id", &self.to_string())?;`
`63`		`- obj.serialize_field("slot", &self.slot)?;`
`64`		`- obj.serialize_field("producer", &self.producer)?;`
`65`		`- obj.end()`
	`61`	`+ serializer.serialize_str(&self.to_string())`
`66`	`62`	`}`
`67`	`63`	`}`
`68`	`64`
`@@ -116,18 +112,12 @@ impl<Node: Display> Display for InputBlockId<Node> {`
`116`	`112`	`}`
`117`	`113`	`}`
`118`	`114`
`119`		`-impl<Node: Display + Serialize> Serialize for InputBlockId<Node> {`
	`115`	`+impl<Node: Display> Serialize for InputBlockId<Node> {`
`120`	`116`	`fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>`
`121`	`117`	`where`
`122`	`118`	`S: serde::Serializer,`
`123`	`119`	`{`
`124`		`- let mut obj = serializer.serialize_struct("InputBlockId", 5)?;`
`125`		`- obj.serialize_field("id", &self.to_string())?;`
`126`		`- obj.serialize_field("slot", &self.slot)?;`
`127`		`- obj.serialize_field("pipeline", &self.pipeline)?;`
`128`		`- obj.serialize_field("producer", &self.producer)?;`
`129`		`- obj.serialize_field("index", &self.index)?;`
`130`		`- obj.end()`
	`120`	`+ serializer.serialize_str(&self.to_string())`
`131`	`121`	`}`
`132`	`122`	`}`
`133`	`123`
`@@ -161,17 +151,12 @@ impl<Node: Display> Display for EndorserBlockId<Node> {`
`161`	`151`	`f.write_fmt(format_args!("{}-{}", self.slot, self.producer))`
`162`	`152`	`}`
`163`	`153`	`}`
`164`		`-impl<Node: Display + Serialize> Serialize for EndorserBlockId<Node> {`
	`154`	`+impl<Node: Display> Serialize for EndorserBlockId<Node> {`
`165`	`155`	`fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>`
`166`	`156`	`where`
`167`	`157`	`S: serde::Serializer,`
`168`	`158`	`{`
`169`		`- let mut obj = serializer.serialize_struct("EndorserBlockId", 4)?;`
`170`		`- obj.serialize_field("id", &self.to_string())?;`
`171`		`- obj.serialize_field("slot", &self.slot)?;`
`172`		`- obj.serialize_field("pipeline", &self.pipeline)?;`
`173`		`- obj.serialize_field("producer", &self.producer)?;`
`174`		`- obj.end()`
	`159`	`+ serializer.serialize_str(&self.to_string())`
`175`	`160`	`}`
`176`	`161`	`}`
`177`	`162`
`@@ -206,17 +191,12 @@ impl<Node: Display> Display for VoteBundleId<Node> {`
`206`	`191`	`f.write_fmt(format_args!("{}-{}", self.slot, self.producer))`
`207`	`192`	`}`
`208`	`193`	`}`
`209`		`-impl<Node: Display + Serialize> Serialize for VoteBundleId<Node> {`
	`194`	`+impl<Node: Display> Serialize for VoteBundleId<Node> {`
`210`	`195`	`fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>`
`211`	`196`	`where`
`212`	`197`	`S: serde::Serializer,`
`213`	`198`	`{`
`214`		`- let mut obj = serializer.serialize_struct("VoteBundleId", 4)?;`
`215`		`- obj.serialize_field("id", &self.to_string())?;`
`216`		`- obj.serialize_field("slot", &self.slot)?;`
`217`		`- obj.serialize_field("pipeline", &self.pipeline)?;`
`218`		`- obj.serialize_field("producer", &self.producer)?;`
`219`		`- obj.end()`
	`199`	`+ serializer.serialize_str(&self.to_string())`
`220`	`200`	`}`
`221`	`201`	`}`
`222`	`202`