Update state-res, use the new Event trait

This also bumps ruma to latest and removes js_int infavor of the ruma
re-export

src/pdu.rs

@@ -1,12 +1,11 @@
 use crate::Error;
-use js_int::UInt;
 use ruma::{
     events::{
         pdu::EventHash, room::member::MemberEventContent, AnyEvent, AnyRoomEvent, AnyStateEvent,
         AnyStrippedStateEvent, AnySyncRoomEvent, AnySyncStateEvent, EventType, StateEvent,
     },
     serde::{to_canonical_value, CanonicalJsonObject, CanonicalJsonValue, Raw},
-    EventId, RoomId, RoomVersionId, ServerName, ServerSigningKeyId, UserId,
+    EventId, RoomId, RoomVersionId, ServerName, ServerSigningKeyId, UInt, UserId,
 };
 use serde::{Deserialize, Serialize};
 use serde_json::json;
@@ -33,8 +32,8 @@ pub struct PduEvent {
     pub auth_events: Vec<EventId>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub redacts: Option<EventId>,
-    #[serde(default, skip_serializing_if = "serde_json::Map::is_empty")]
-    pub unsigned: serde_json::Map<String, serde_json::Value>,
+    #[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
+    pub unsigned: BTreeMap<String, serde_json::Value>,
     pub hashes: EventHash,
     pub signatures: BTreeMap<Box<ServerName>, BTreeMap<ServerSigningKeyId, String>>,
 }
@@ -227,61 +226,66 @@ impl PduEvent {
         )
         .expect("Raw::from_value always works")
     }
-}
 
-impl From<&state_res::StateEvent> for PduEvent {
-    fn from(pdu: &state_res::StateEvent) -> Self {
-        Self {
-            event_id: pdu.event_id(),
-            room_id: pdu.room_id().clone(),
-            sender: pdu.sender().clone(),
-            origin_server_ts: (pdu
-                .origin_server_ts()
-                .duration_since(UNIX_EPOCH)
-                .expect("time is valid")
-                .as_millis() as u64)
-                .try_into()
-                .expect("time is valid"),
-            kind: pdu.kind(),
-            content: pdu.content().clone(),
-            state_key: Some(pdu.state_key()),
-            prev_events: pdu.prev_event_ids(),
-            depth: *pdu.depth(),
-            auth_events: pdu.auth_events(),
-            redacts: pdu.redacts().cloned(),
-            unsigned: pdu.unsigned().clone().into_iter().collect(),
-            hashes: pdu.hashes().clone(),
-            signatures: pdu.signatures(),
-        }
+    pub fn from_id_val(
+        event_id: &EventId,
+        json: CanonicalJsonObject,
+    ) -> Result<Self, serde_json::Error> {
+        json.insert(
+            "event_id".to_string(),
+            ruma::serde::to_canonical_value(event_id).expect("event_id is a valid Value"),
+        );
+
+        serde_json::from_value(serde_json::to_value(json).expect("valid JSON"))
     }
 }
 
-impl PduEvent {
-    pub fn convert_for_state_res(&self) -> Arc<state_res::StateEvent> {
-        Arc::new(
-            // For consistency of eventId (just in case) we use the one
-            // generated by conduit for everything.
-            state_res::StateEvent::from_id_value(
-                self.event_id.clone(),
-                json!({
-                    "event_id": self.event_id,
-                    "room_id": self.room_id,
-                    "sender": self.sender,
-                    "origin_server_ts": self.origin_server_ts,
-                    "type": self.kind,
-                    "content": self.content,
-                    "state_key": self.state_key,
-                    "prev_events": self.prev_events,
-                    "depth": self.depth,
-                    "auth_events": self.auth_events,
-                    "redacts": self.redacts,
-                    "unsigned": self.unsigned,
-                    "hashes": self.hashes,
-                    "signatures": self.signatures,
-                }),
-            )
-            .expect("all conduit PDUs are state events"),
-        )
+impl state_res::Event for PduEvent {
+    fn event_id(&self) -> &EventId {
+        &self.event_id
+    }
+
+    fn room_id(&self) -> &RoomId {
+        &self.room_id
+    }
+
+    fn sender(&self) -> &UserId {
+        &self.sender
+    }
+    fn kind(&self) -> EventType {
+        self.kind.clone()
+    }
+
+    fn content(&self) -> serde_json::Value {
+        self.content.clone()
+    }
+    fn origin_server_ts(&self) -> std::time::SystemTime {
+        UNIX_EPOCH + std::time::Duration::from_millis(self.origin_server_ts.into())
+    }
+
+    fn state_key(&self) -> Option<String> {
+        self.state_key.clone()
+    }
+    fn prev_events(&self) -> Vec<EventId> {
+        self.prev_events.to_vec()
+    }
+    fn depth(&self) -> &UInt {
+        &self.depth
+    }
+    fn auth_events(&self) -> Vec<EventId> {
+        self.auth_events.to_vec()
+    }
+    fn redacts(&self) -> Option<&EventId> {
+        self.redacts.as_ref()
+    }
+    fn hashes(&self) -> &EventHash {
+        &self.hashes
+    }
+    fn signatures(&self) -> BTreeMap<Box<ServerName>, BTreeMap<ruma::ServerSigningKeyId, String>> {
+        self.signatures.clone()
+    }
+    fn unsigned(&self) -> &BTreeMap<String, serde_json::Value> {
+        &self.unsigned
     }
 }
 
@@ -315,7 +319,7 @@ pub struct PduBuilder {
     #[serde(rename = "type")]
     pub event_type: EventType,
     pub content: serde_json::Value,
-    pub unsigned: Option<serde_json::Map<String, serde_json::Value>>,
+    pub unsigned: Option<BTreeMap<String, serde_json::Value>>,
     pub state_key: Option<String>,
     pub redacts: Option<EventId>,
 }