use core::fmt;
use std::any::{Any, TypeId};
use std::borrow::Cow;
use std::collections::BTreeMap;
use std::fmt::{Debug, Display, Formatter};
use std::io::Read;
use std::str::FromStr;
use std::sync::Arc;
use anyhow::anyhow;
pub use bitcoin::KeyPair;
use fedimint_core::encoding::{Decodable, DecodeError, DynEncodable, Encodable};
use fedimint_core::module::registry::ModuleDecoderRegistry;
use rand::RngCore;
use serde::{Deserialize, Deserializer, Serialize};
use crate::{
erased_eq_no_instance_id, module_plugin_dyn_newtype_clone_passthrough,
module_plugin_dyn_newtype_define, module_plugin_dyn_newtype_display_passthrough,
module_plugin_dyn_newtype_encode_decode, module_plugin_dyn_newtype_eq_passthrough,
module_plugin_static_trait_define, module_plugin_static_trait_define_config,
};
pub mod server;
pub mod backup;
#[derive(Clone, Copy, PartialEq, Eq, Hash, Encodable, Decodable)]
pub struct OperationId(pub [u8; 32]);
impl OperationId {
pub fn new_random() -> Self {
let mut rng = rand::thread_rng();
let mut bytes = [0u8; 32];
rng.fill_bytes(&mut bytes);
Self(bytes)
}
}
impl Display for OperationId {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
bitcoin_hashes::hex::format_hex(&self.0, f)
}
}
impl Debug for OperationId {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
write!(f, "OperationId({self})")
}
}
impl FromStr for OperationId {
type Err = anyhow::Error;
fn from_str(s: &str) -> Result<Self, Self::Err> {
let bytes: [u8; 32] = bitcoin_hashes::hex::FromHex::from_hex(s)?;
Ok(OperationId(bytes))
}
}
impl Serialize for OperationId {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
if serializer.is_human_readable() {
serializer.serialize_str(&self.to_string())
} else {
serializer.serialize_bytes(&self.0)
}
}
}
impl<'de> Deserialize<'de> for OperationId {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
if deserializer.is_human_readable() {
let s = String::deserialize(deserializer)?;
let operation_id = OperationId::from_str(&s)
.map_err(|e| serde::de::Error::custom(format!("invalid operation id: {e}")))?;
Ok(operation_id)
} else {
let bytes: [u8; 32] = <[u8; 32]>::deserialize(deserializer)?;
Ok(OperationId(bytes))
}
}
}
pub type ModuleInstanceId = u16;
pub const MODULE_INSTANCE_ID_GLOBAL: u16 = u16::MAX;
pub const LEGACY_HARDCODED_INSTANCE_ID_LN: ModuleInstanceId = 0;
pub const LEGACY_HARDCODED_INSTANCE_ID_MINT: ModuleInstanceId = 1;
pub const LEGACY_HARDCODED_INSTANCE_ID_WALLET: ModuleInstanceId = 2;
#[derive(
Debug, PartialEq, Eq, Clone, PartialOrd, Ord, Serialize, Deserialize, Encodable, Decodable,
)]
pub struct ModuleKind(Cow<'static, str>);
impl ModuleKind {
pub fn clone_from_str(s: &str) -> Self {
Self(Cow::from(s.to_owned()))
}
pub const fn from_static_str(s: &'static str) -> Self {
Self(Cow::Borrowed(s))
}
pub fn as_str(&self) -> &str {
&self.0
}
}
impl fmt::Display for ModuleKind {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
std::fmt::Display::fmt(&self.0, f)
}
}
impl From<&'static str> for ModuleKind {
fn from(val: &'static str) -> Self {
ModuleKind::from_static_str(val)
}
}
#[derive(Encodable, Decodable, Debug, Hash, PartialEq, Clone)]
pub struct DynUnknown(pub Vec<u8>);
impl fmt::Display for DynUnknown {
fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
f.write_str(&self.0.consensus_encode_to_hex().expect("can't fail"))
}
}
pub trait IntoDynInstance {
type DynType: 'static;
fn into_dyn(self, instance_id: ModuleInstanceId) -> Self::DynType;
}
type DecodeFn = for<'a> fn(
Box<dyn Read + 'a>,
ModuleInstanceId,
&ModuleDecoderRegistry,
) -> Result<Box<dyn Any>, DecodeError>;
#[derive(Default)]
pub struct DecoderBuilder {
decode_fns: BTreeMap<TypeId, DecodeFn>,
}
impl DecoderBuilder {
pub fn build(self) -> Decoder {
Decoder {
decode_fns: Arc::new(self.decode_fns),
}
}
pub fn with_decodable_type<Type>(&mut self)
where
Type: IntoDynInstance + Decodable,
{
let decode_fn: DecodeFn = |mut reader, instance, modules| {
let typed_val = Type::consensus_decode(&mut reader, modules)?;
let dyn_val = typed_val.into_dyn(instance);
let any_val: Box<dyn Any> = Box::new(dyn_val);
Ok(any_val)
};
if self
.decode_fns
.insert(TypeId::of::<Type::DynType>(), decode_fn)
.is_some()
{
panic!("Tried to add multiple decoders for the same DynType");
}
}
}
#[derive(Clone, Default)]
pub struct Decoder {
decode_fns: Arc<BTreeMap<TypeId, DecodeFn>>,
}
impl Decoder {
pub fn builder() -> DecoderBuilder {
DecoderBuilder::default()
}
pub fn decode<DynType: Any>(
&self,
reader: &mut dyn Read,
instance_id: ModuleInstanceId,
modules: &ModuleDecoderRegistry,
) -> Result<DynType, DecodeError> {
let decode_fn = self
.decode_fns
.get(&TypeId::of::<DynType>())
.ok_or_else(|| {
anyhow!(
"Type unknown to decoder: {}, (registered decoders={})",
std::any::type_name::<DynType>(),
self.decode_fns.len()
)
})
.expect("Types being decoded must be registered");
Ok(*decode_fn(Box::new(reader), instance_id, modules)?
.downcast::<DynType>()
.expect("Decode fn returned wrong type, can't happen due to with_decodable_type"))
}
}
impl Debug for Decoder {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
write!(f, "Decoder(registered_types = {})", self.decode_fns.len())
}
}
pub trait IClientConfig: Debug + Display + DynEncodable {
fn as_any(&self) -> &(dyn Any + Send + Sync);
fn clone(&self, instance_id: ModuleInstanceId) -> DynClientConfig;
fn dyn_hash(&self) -> u64;
fn erased_eq_no_instance_id(&self, other: &DynClientConfig) -> bool;
fn to_json(&self) -> Option<serde_json::Value>;
}
module_plugin_static_trait_define_config! {
DynClientConfig, ClientConfig, IClientConfig,
{ },
{
erased_eq_no_instance_id!(DynClientConfig);
fn to_json(&self) -> Option<serde_json::Value> {
Some(serde_json::to_value(self.to_owned()).expect("serialization can't fail"))
}
},
{
erased_eq_no_instance_id!(DynClientConfig);
fn to_json(&self) -> Option<serde_json::Value> {
None
}
}
}
module_plugin_dyn_newtype_define! {
pub DynClientConfig(Box<IClientConfig>)
}
module_plugin_dyn_newtype_encode_decode!(DynClientConfig);
module_plugin_dyn_newtype_clone_passthrough!(DynClientConfig);
module_plugin_dyn_newtype_eq_passthrough!(DynClientConfig);
module_plugin_dyn_newtype_display_passthrough!(DynClientConfig);
pub trait IInput: Debug + Display + DynEncodable {
fn as_any(&self) -> &(dyn Any + Send + Sync);
fn clone(&self, instance_id: ModuleInstanceId) -> DynInput;
fn dyn_hash(&self) -> u64;
fn erased_eq_no_instance_id(&self, other: &DynInput) -> bool;
}
module_plugin_static_trait_define! {
DynInput, Input, IInput,
{ },
{
erased_eq_no_instance_id!(DynInput);
}
}
module_plugin_dyn_newtype_define! {
pub DynInput(Box<IInput>)
}
module_plugin_dyn_newtype_encode_decode!(DynInput);
module_plugin_dyn_newtype_clone_passthrough!(DynInput);
module_plugin_dyn_newtype_eq_passthrough!(DynInput);
module_plugin_dyn_newtype_display_passthrough!(DynInput);
pub trait IOutput: Debug + Display + DynEncodable {
fn as_any(&self) -> &(dyn Any + Send + Sync);
fn clone(&self, instance_id: ModuleInstanceId) -> DynOutput;
fn dyn_hash(&self) -> u64;
fn erased_eq_no_instance_id(&self, other: &DynOutput) -> bool;
}
module_plugin_dyn_newtype_define! {
pub DynOutput(Box<IOutput>)
}
module_plugin_static_trait_define! {
DynOutput, Output, IOutput,
{ },
{
erased_eq_no_instance_id!(DynOutput);
}
}
module_plugin_dyn_newtype_encode_decode!(DynOutput);
module_plugin_dyn_newtype_clone_passthrough!(DynOutput);
module_plugin_dyn_newtype_eq_passthrough!(DynOutput);
module_plugin_dyn_newtype_display_passthrough!(DynOutput);
pub enum FinalizationError {
SomethingWentWrong,
}
pub trait IOutputOutcome: Debug + Display + DynEncodable {
fn as_any(&self) -> &(dyn Any + Send + Sync);
fn clone(&self, module_instance_id: ModuleInstanceId) -> DynOutputOutcome;
fn dyn_hash(&self) -> u64;
fn erased_eq_no_instance_id(&self, other: &DynOutputOutcome) -> bool;
}
module_plugin_dyn_newtype_define! {
pub DynOutputOutcome(Box<IOutputOutcome>)
}
module_plugin_static_trait_define! {
DynOutputOutcome, OutputOutcome, IOutputOutcome,
{ },
{
erased_eq_no_instance_id!(DynOutputOutcome);
}
}
module_plugin_dyn_newtype_encode_decode!(DynOutputOutcome);
module_plugin_dyn_newtype_clone_passthrough!(DynOutputOutcome);
module_plugin_dyn_newtype_eq_passthrough!(DynOutputOutcome);
module_plugin_dyn_newtype_display_passthrough!(DynOutputOutcome);
pub trait IModuleConsensusItem: Debug + Display + DynEncodable {
fn as_any(&self) -> &(dyn Any + Send + Sync);
fn clone(&self, module_instance_id: ModuleInstanceId) -> DynModuleConsensusItem;
fn dyn_hash(&self) -> u64;
fn erased_eq_no_instance_id(&self, other: &DynModuleConsensusItem) -> bool;
}
module_plugin_dyn_newtype_define! {
pub DynModuleConsensusItem(Box<IModuleConsensusItem>)
}
module_plugin_static_trait_define! {
DynModuleConsensusItem, ModuleConsensusItem, IModuleConsensusItem,
{ },
{
erased_eq_no_instance_id!(DynModuleConsensusItem);
}
}
module_plugin_dyn_newtype_encode_decode!(DynModuleConsensusItem);
module_plugin_dyn_newtype_clone_passthrough!(DynModuleConsensusItem);
module_plugin_dyn_newtype_eq_passthrough!(DynModuleConsensusItem);
module_plugin_dyn_newtype_display_passthrough!(DynModuleConsensusItem);
pub trait IOutputError: Debug + Display + DynEncodable {
fn as_any(&self) -> &(dyn Any + Send + Sync);
fn clone(&self, module_instance_id: ModuleInstanceId) -> DynOutputError;
fn dyn_hash(&self) -> u64;
fn erased_eq_no_instance_id(&self, other: &DynOutputError) -> bool;
}
module_plugin_dyn_newtype_define! {
pub DynOutputError(Box<IOutputError>)
}
module_plugin_static_trait_define! {
DynOutputError, OutputError, IOutputError,
{ },
{
erased_eq_no_instance_id!(DynOutputError);
}
}
module_plugin_dyn_newtype_encode_decode!(DynOutputError);
module_plugin_dyn_newtype_clone_passthrough!(DynOutputError);
module_plugin_dyn_newtype_eq_passthrough!(DynOutputError);
module_plugin_dyn_newtype_display_passthrough!(DynOutputError);
pub trait IInputError: Debug + Display + DynEncodable {
fn as_any(&self) -> &(dyn Any + Send + Sync);
fn clone(&self, module_instance_id: ModuleInstanceId) -> DynInputError;
fn dyn_hash(&self) -> u64;
fn erased_eq_no_instance_id(&self, other: &DynInputError) -> bool;
}
module_plugin_dyn_newtype_define! {
pub DynInputError(Box<IInputError>)
}
module_plugin_static_trait_define! {
DynInputError, InputError, IInputError,
{ },
{
erased_eq_no_instance_id!(DynInputError);
}
}
module_plugin_dyn_newtype_encode_decode!(DynInputError);
module_plugin_dyn_newtype_clone_passthrough!(DynInputError);
module_plugin_dyn_newtype_eq_passthrough!(DynInputError);
module_plugin_dyn_newtype_display_passthrough!(DynInputError);