refactor checkpoint

veilid-core/src/veilid_api/mod.rs

@@ -27,11 +27,8 @@ pub use routing_table::{NodeRef, NodeRefBase};
 use crate::*;
 use core::fmt;
 use core_context::{api_shutdown, VeilidCoreContext};
-use enumset::*;
-use rkyv::{Archive as RkyvArchive, Deserialize as RkyvDeserialize, Serialize as RkyvSerialize};
 use routing_table::{Direction, RouteSpecStore, RoutingTable};
 use rpc_processor::*;
-use serde::*;
 use storage_manager::StorageManager;
 
 /////////////////////////////////////////////////////////////////////////////////////////////////////

veilid-core/src/veilid_api/serialize_helpers.rs

@@ -1,9 +1,6 @@
 use super::*;
-pub use bytecheck::CheckBytes;
+
 use core::fmt::Debug;
-use rkyv::Archive as RkyvArchive;
-use rkyv::Deserialize as RkyvDeserialize;
-use rkyv::Serialize as RkyvSerialize;
 
 // Don't trace these functions as they are used in the transfer of API logs, which will recurse!
 
@@ -146,7 +143,7 @@ pub fn from_rkyv<T>(v: Vec<u8>) -> EyreResult<T>
 where
     T: RkyvArchive,
     <T as RkyvArchive>::Archived:
-        for<'t> bytecheck::CheckBytes<rkyv::validation::validators::DefaultValidator<'t>>,
+        for<'t> CheckBytes<rkyv::validation::validators::DefaultValidator<'t>>,
     <T as RkyvArchive>::Archived:
         rkyv::Deserialize<T, rkyv::de::deserializers::SharedDeserializeMap>,
 {

veilid-core/src/veilid_api/types/app_message_call.rs

@@ -14,6 +14,19 @@ pub struct VeilidAppMessage {
     pub message: Vec<u8>,
 }
 
+impl VeilidAppMessage {
+    pub fn new(sender: Option<PublicKey>, message: Vec<u8>) -> Self {
+        Self { sender, message }
+    }
+
+    pub fn sender(&self) -> Option<&PublicKey> {
+        self.sender.as_ref()
+    }
+    pub fn message(&self) -> &[u8] {
+        &self.message
+    }
+}
+
 /// Direct question blob passed to hosting application for processing to send an eventual AppReply
 #[derive(
     Debug, Clone, PartialEq, Eq, Serialize, Deserialize, RkyvArchive, RkyvSerialize, RkyvDeserialize,
@@ -22,11 +35,31 @@ pub struct VeilidAppMessage {
 pub struct VeilidAppCall {
     /// Some(sender) if the request was sent directly, None if received via a private/safety route
     #[serde(with = "opt_json_as_string")]
-    pub sender: Option<PublicKey>,
+    sender: Option<PublicKey>,
     /// The content of the request to deliver to the application
     #[serde(with = "json_as_base64")]
-    pub message: Vec<u8>,
+    message: Vec<u8>,
     /// The id to reply to
     #[serde(with = "json_as_string")]
-    pub id: OperationId,
+    id: OperationId,
+}
+
+impl VeilidAppCall {
+    pub fn new(sender: Option<PublicKey>, message: Vec<u8>, id: OperationId) -> Self {
+        Self {
+            sender,
+            message,
+            id,
+        }
+    }
+
+    pub fn sender(&self) -> Option<&PublicKey> {
+        self.sender.as_ref()
+    }
+    pub fn message(&self) -> &[u8] {
+        &self.message
+    }
+    pub fn id(&self) -> OperationId {
+        self.id
+    }
 }