#![deny(missing_docs)]
#[allow(missing_docs)]
pub mod agent_activity;
pub mod bytes;
#[allow(missing_docs)]
pub mod call;
#[allow(missing_docs)]
pub mod call_remote;
pub mod capability;
pub mod cell;
#[allow(missing_docs)]
pub mod crdt;
pub mod element;
pub mod entry;
#[allow(missing_docs)]
pub mod entry_def;
#[allow(missing_docs)]
pub mod header;
#[allow(missing_docs)]
pub mod info;
#[allow(missing_docs)]
pub mod init;
#[allow(missing_docs)]
pub mod link;
pub mod metadata;
#[allow(missing_docs)]
pub mod migrate_agent;
#[allow(missing_docs)]
pub mod post_commit;
pub mod prelude;
pub mod query;
pub mod request;
pub mod signal;
pub mod signature;
pub mod timestamp;
pub mod trace;
#[allow(missing_docs)]
pub mod validate;
#[allow(missing_docs)]
pub mod validate_link;
pub mod version;
pub mod warrant;
#[allow(missing_docs)]
pub mod x_salsa20_poly1305;
#[allow(missing_docs)]
pub mod zome;
#[allow(missing_docs)]
pub mod zome_io;
#[allow(missing_docs)]
#[cfg(feature = "fixturators")]
pub mod fixt;
#[cfg(feature = "test_utils")]
pub mod test_utils;
pub use entry::Entry;
pub use header::Header;
pub use prelude::*;
#[allow(missing_docs)]
pub trait CallbackResult {
fn is_definitive(&self) -> bool;
}
#[macro_export]
macro_rules! fixed_array_serialization {
($t:ty, $len:expr) => {
impl serde::ser::Serialize for $t {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: serde::ser::Serializer,
{
serializer.serialize_bytes(&self.0)
}
}
impl<'de> serde::de::Deserialize<'de> for $t {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: serde::de::Deserializer<'de>,
{
use serde::de::Error;
let bytes: &[u8] = serde::de::Deserialize::deserialize(deserializer)?;
if bytes.len() != $len {
let exp_msg = format!("expected {} bytes got: {} bytes", $len, bytes.len());
return Err(D::Error::invalid_value(
serde::de::Unexpected::Bytes(bytes),
&exp_msg.as_str(),
));
}
let mut inner: [u8; $len] = [0; $len];
inner.clone_from_slice(bytes);
Ok(Self(inner))
}
}
};
}
#[derive(Debug, thiserror::Error)]
pub enum SecurePrimitiveError {
#[error("Bad sized secure primitive.")]
BadSize,
}
#[macro_export]
macro_rules! secure_primitive {
($t:ty, $len:expr) => {
$crate::fixed_array_serialization!($t, $len);
impl PartialEq for $t {
fn eq(&self, other: &Self) -> bool {
use subtle::ConstantTimeEq;
self.0.ct_eq(&other.0).into()
}
}
impl Eq for $t {}
impl std::fmt::Debug for $t {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
std::fmt::Debug::fmt(&self.0.to_vec(), f)
}
}
impl From<[u8; $len]> for $t {
fn from(b: [u8; $len]) -> Self {
Self(b)
}
}
impl TryFrom<&[u8]> for $t {
type Error = $crate::SecurePrimitiveError;
fn try_from(slice: &[u8]) -> Result<$t, Self::Error> {
if slice.len() == $len {
let mut inner = [0; $len];
inner.copy_from_slice(slice);
Ok(inner.into())
} else {
Err($crate::SecurePrimitiveError::BadSize)
}
}
}
impl AsRef<[u8]> for $t {
fn as_ref(&self) -> &[u8] {
&self.0
}
}
};
}