126 lines
3.1 KiB
Rust
126 lines
3.1 KiB
Rust
use std::fmt::Debug;
|
|
use std::str::FromStr;
|
|
use std::sync::{Mutex, MutexGuard};
|
|
|
|
pub use aes_gcm;
|
|
pub use ciborium;
|
|
pub use env_logger;
|
|
pub use log;
|
|
pub use rand;
|
|
pub use sp_client;
|
|
pub use serde;
|
|
pub use serde_json;
|
|
pub use serde_wasm_bindgen;
|
|
pub use tsify;
|
|
pub use wasm_bindgen;
|
|
pub use js_sys;
|
|
|
|
pub mod crypto;
|
|
pub mod device;
|
|
pub mod hash;
|
|
pub mod error;
|
|
pub mod network;
|
|
pub mod pcd;
|
|
pub mod prd;
|
|
pub mod process;
|
|
pub mod secrets;
|
|
pub mod serialization;
|
|
pub mod signature;
|
|
pub mod silentpayments;
|
|
|
|
pub const MAX_PRD_PAYLOAD_SIZE: usize = u16::MAX as usize; // 64KiB sounds reasonable for now
|
|
|
|
const DEMIURGE: &str = "demiurge";
|
|
const PAIRING: &str = "pairing";
|
|
const APOPHIS: &str = "apophis";
|
|
|
|
const MEMBERPUBLICNAME: &str = "memberPublicName";
|
|
const PAIREDADDRESSES: &str = "pairedAddresses";
|
|
|
|
const ROLESLABEL: &str = "roles";
|
|
|
|
#[derive(Debug, PartialEq, Eq)]
|
|
pub enum SpecialRoles {
|
|
Demiurge, // Only valid for the first state of a process
|
|
Pairing, // Special validation rules for pairing process
|
|
Apophis, // Users in this role have the power to destroy the process
|
|
}
|
|
|
|
impl std::fmt::Display for SpecialRoles {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
write!(f, "{}", <&Self as Into<&str>>::into(self))
|
|
}
|
|
}
|
|
|
|
impl From<&SpecialRoles> for &str {
|
|
fn from(value: &SpecialRoles) -> Self {
|
|
match value {
|
|
SpecialRoles::Demiurge => DEMIURGE,
|
|
SpecialRoles::Pairing => PAIRING,
|
|
SpecialRoles::Apophis => APOPHIS,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl FromStr for SpecialRoles {
|
|
type Err = String;
|
|
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s {
|
|
DEMIURGE => Ok(SpecialRoles::Demiurge),
|
|
PAIRING => Ok(SpecialRoles::Pairing),
|
|
APOPHIS => Ok(SpecialRoles::Apophis),
|
|
_ => Err(format!("Invalid special role: {}", s)),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, PartialEq, Eq)]
|
|
pub enum ReservedFields {
|
|
PairedAddresses,
|
|
MemberPublicName,
|
|
}
|
|
|
|
impl From<&ReservedFields> for &str {
|
|
fn from(value: &ReservedFields) -> Self {
|
|
match value {
|
|
ReservedFields::MemberPublicName => MEMBERPUBLICNAME,
|
|
ReservedFields::PairedAddresses => PAIREDADDRESSES,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl FromStr for ReservedFields {
|
|
type Err = String;
|
|
|
|
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
|
match s {
|
|
MEMBERPUBLICNAME => Ok(ReservedFields::MemberPublicName),
|
|
PAIREDADDRESSES => Ok(ReservedFields::PairedAddresses),
|
|
_ => Err(format!("Invalid field name: {}", s)),
|
|
}
|
|
}
|
|
}
|
|
|
|
pub trait MutexExt<T> {
|
|
fn lock_anyhow(&self) -> Result<MutexGuard<T>, anyhow::Error>;
|
|
}
|
|
|
|
impl<T: Debug> MutexExt<T> for Mutex<T> {
|
|
fn lock_anyhow(&self) -> Result<MutexGuard<T>, anyhow::Error> {
|
|
match self.lock() {
|
|
Ok(guard) => Ok(guard),
|
|
Err(poison_error) => {
|
|
let data = poison_error.into_inner();
|
|
|
|
log::debug!(
|
|
"Failed to lock Mutex (poisoned). Data was: {:?}",
|
|
data
|
|
);
|
|
|
|
Err(anyhow::anyhow!("Failed to lock Mutex (poisoned)"))
|
|
}
|
|
}
|
|
}
|
|
}
|