devimint/federation/
config.rs

1use bitcoincore_rpc::bitcoin::Network;
2use fedimint_core::config::{EmptyGenParams, ServerModuleConfigGenParamsRegistry};
3use fedimint_core::envs::{BitcoinRpcConfig, FM_USE_UNKNOWN_MODULE_ENV, is_env_var_set};
4use fedimint_ln_server::LightningInit;
5use fedimint_ln_server::common::config::{
6    LightningGenParams, LightningGenParamsConsensus, LightningGenParamsLocal,
7};
8use fedimint_meta_server::{MetaGenParams, MetaInit};
9use fedimint_mint_server::MintInit;
10use fedimint_mint_server::common::config::{MintGenParams, MintGenParamsConsensus};
11use fedimint_server::core::ServerModuleInit as _;
12use fedimint_unknown_server::UnknownInit;
13use fedimint_unknown_server::common::config::UnknownGenParams;
14use fedimint_wallet_client::config::{
15    WalletGenParams, WalletGenParamsConsensus, WalletGenParamsLocal,
16};
17use fedimint_wallet_server::WalletInit;
18use fedimintd::default_esplora_server;
19use fedimintd::envs::FM_DISABLE_META_MODULE_ENV;
20use legacy_types::{LegacyFeeConsensus, LegacyMintGenParams, LegacyMintGenParamsConsensus};
21
22use crate::util::supports_lnv2;
23use crate::version_constants::VERSION_0_5_0_ALPHA;
24
25/// Duplicate default fedimint module setup
26pub fn attach_default_module_init_params(
27    bitcoin_rpc: &BitcoinRpcConfig,
28    module_init_params: &mut ServerModuleConfigGenParamsRegistry,
29    network: Network,
30    finality_delay: u32,
31    fedimintd_version: &semver::Version,
32) {
33    module_init_params.attach_config_gen_params(
34        LightningInit::kind(),
35        LightningGenParams {
36            local: LightningGenParamsLocal {
37                bitcoin_rpc: bitcoin_rpc.clone(),
38            },
39            consensus: LightningGenParamsConsensus { network },
40        },
41    );
42
43    // TODO(support:v0.4): v0.5 introduced relative fees for the mint module by
44    // changing the field names for FeeConsensus. We need to support the old fields
45    // in devimint since fedimint-cli uses JSON encoding for admin dkg
46    if fedimintd_version >= &VERSION_0_5_0_ALPHA {
47        module_init_params.attach_config_gen_params(
48            MintInit::kind(),
49            MintGenParams {
50                local: EmptyGenParams::default(),
51                consensus: MintGenParamsConsensus::new(
52                    2,
53                    fedimint_mint_common::config::FeeConsensus::zero(),
54                ),
55            },
56        )
57    } else {
58        module_init_params.attach_config_gen_params(
59            MintInit::kind(),
60            LegacyMintGenParams {
61                local: EmptyGenParams::default(),
62                consensus: LegacyMintGenParamsConsensus::new(2, LegacyFeeConsensus::default()),
63            },
64        )
65    };
66
67    module_init_params.attach_config_gen_params(
68        WalletInit::kind(),
69        WalletGenParams {
70            local: WalletGenParamsLocal {
71                bitcoin_rpc: bitcoin_rpc.clone(),
72            },
73            consensus: WalletGenParamsConsensus {
74                network,
75                finality_delay,
76                client_default_bitcoin_rpc: default_esplora_server(network),
77                fee_consensus: fedimint_wallet_client::config::FeeConsensus::default(),
78            },
79        },
80    );
81
82    if supports_lnv2() {
83        module_init_params.attach_config_gen_params(
84            fedimint_lnv2_server::LightningInit::kind(),
85            fedimint_lnv2_common::config::LightningGenParams {
86                local: fedimint_lnv2_common::config::LightningGenParamsLocal {
87                    bitcoin_rpc: bitcoin_rpc.clone(),
88                },
89                consensus: fedimint_lnv2_common::config::LightningGenParamsConsensus {
90                    fee_consensus: fedimint_lnv2_common::config::FeeConsensus::new(1000)
91                        .expect("Relative fee is within range"),
92                    network,
93                },
94            },
95        );
96    }
97
98    if !is_env_var_set(FM_DISABLE_META_MODULE_ENV) {
99        module_init_params.attach_config_gen_params(MetaInit::kind(), MetaGenParams::default());
100    }
101
102    if is_env_var_set(FM_USE_UNKNOWN_MODULE_ENV) {
103        module_init_params
104            .attach_config_gen_params(UnknownInit::kind(), UnknownGenParams::default());
105    }
106}
107
108mod legacy_types {
109    use fedimint_core::config::EmptyGenParams;
110    use fedimint_core::encoding::{Decodable, Encodable};
111    use serde::{Deserialize, Serialize};
112
113    #[derive(Debug, Clone, Serialize, Deserialize)]
114    pub struct LegacyMintGenParams {
115        pub local: EmptyGenParams,
116        pub consensus: LegacyMintGenParamsConsensus,
117    }
118
119    #[derive(Debug, Clone, Eq, PartialEq, Hash, Serialize, Deserialize, Encodable, Decodable)]
120    pub struct LegacyFeeConsensus {
121        pub note_issuance_abs: fedimint_core::Amount,
122        pub note_spend_abs: fedimint_core::Amount,
123    }
124
125    impl Default for LegacyFeeConsensus {
126        fn default() -> Self {
127            Self {
128                note_issuance_abs: fedimint_core::Amount::ZERO,
129                note_spend_abs: fedimint_core::Amount::ZERO,
130            }
131        }
132    }
133
134    #[derive(Debug, Clone, Serialize, Deserialize)]
135    pub struct LegacyMintGenParamsConsensus {
136        denomination_base: u16,
137        fee_consensus: LegacyFeeConsensus,
138    }
139
140    impl LegacyMintGenParamsConsensus {
141        pub fn new(denomination_base: u16, fee_consensus: LegacyFeeConsensus) -> Self {
142            Self {
143                denomination_base,
144                fee_consensus,
145            }
146        }
147    }
148
149    impl fedimint_core::config::ModuleInitParams for LegacyMintGenParams {
150        type Local = EmptyGenParams;
151        type Consensus = LegacyMintGenParamsConsensus;
152
153        fn from_parts(local: Self::Local, consensus: Self::Consensus) -> Self {
154            Self { local, consensus }
155        }
156
157        fn to_parts(self) -> (Self::Local, Self::Consensus) {
158            (self.local, self.consensus)
159        }
160    }
161}