#![deny(missing_docs)]
#[allow(missing_docs)]
pub mod action;
#[allow(missing_docs)]
pub mod agent_activity;
pub mod bytes;
#[allow(missing_docs)]
pub mod call;
pub mod capability;
pub mod cell;
#[allow(missing_docs)]
pub mod chain;
pub mod countersigning;
#[allow(missing_docs)]
pub mod crdt;
pub mod dna_def;
pub mod entry;
#[allow(missing_docs)]
pub mod entry_def;
pub mod genesis;
#[allow(missing_docs)]
pub mod hash;
#[allow(missing_docs)]
pub mod info;
#[allow(missing_docs)]
pub mod init;
pub mod judged;
#[allow(missing_docs)]
pub mod link;
pub mod metadata;
#[allow(missing_docs)]
pub mod migrate_agent;
#[allow(missing_docs)]
pub mod op;
pub mod prelude;
#[cfg(feature = "properties")]
pub mod properties;
pub mod query;
pub mod rate_limit;
pub mod record;
pub mod request;
pub mod schedule;
pub mod signal;
pub mod signature;
pub use kitsune_p2p_timestamp as timestamp;
pub mod trace;
#[allow(missing_docs)]
pub mod validate;
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 action::Action;
pub use entry::Entry;
pub use prelude::*;
pub mod dependencies {
pub use ::subtle;
}
use holochain_wasmer_common::WasmError;
#[allow(missing_docs)]
pub trait CallbackResult: Sized {
fn is_definitive(&self) -> bool;
fn try_from_wasm_error(wasm_error: WasmError) -> Result<Self, WasmError>;
}
#[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 $crate::dependencies::subtle::ConstantTimeEq;
self.0.ct_eq(&other.0).into()
}
}
impl Eq for $t {}
#[cfg(not(feature = "subtle-encoding"))]
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)
}
}
#[cfg(feature = "subtle-encoding")]
impl std::fmt::Debug for $t {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let str = String::from_utf8(subtle_encoding::hex::encode(self.0.to_vec()))
.unwrap_or_else(|_| "<unparseable signature>".into());
f.write_str(&str)
}
}
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<Self, 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 TryFrom<Vec<u8>> for $t {
type Error = $crate::SecurePrimitiveError;
fn try_from(v: Vec<u8>) -> Result<Self, Self::Error> {
Self::try_from(v.as_ref())
}
}
impl AsRef<[u8]> for $t {
fn as_ref(&self) -> &[u8] {
&self.0
}
}
};
}
#[macro_export]
macro_rules! impl_to_sql_via_as_ref {
($s: ty) => {
impl ::rusqlite::ToSql for $s {
fn to_sql(&self) -> ::rusqlite::Result<::rusqlite::types::ToSqlOutput<'_>> {
Ok(::rusqlite::types::ToSqlOutput::Borrowed(
self.as_ref().into(),
))
}
}
};
}
#[macro_export]
macro_rules! impl_to_sql_via_display {
($s: ty) => {
impl ::rusqlite::ToSql for $s {
fn to_sql(&self) -> ::rusqlite::Result<::rusqlite::types::ToSqlOutput<'_>> {
Ok(::rusqlite::types::ToSqlOutput::Owned(
self.to_string().into(),
))
}
}
};
}
#[cfg(any(test, feature = "test_utils"))]
pub static NOISE: once_cell::sync::Lazy<Vec<u8>> = once_cell::sync::Lazy::new(|| {
use rand::Rng;
let mut rng = rand::thread_rng();
std::iter::repeat_with(|| rng.gen())
.take(10_000_000)
.collect()
});