Struct Federation 

pub struct Federation {
    pub members: BTreeMap<usize, Fedimintd>,
    pub vars: BTreeMap<usize, Fedimintd>,
    pub bitcoind: Bitcoind,
    client: JitTryAnyhow<Client>,
    connectors: ConnectorRegistry,
}

Fields

members: BTreeMap<usize, Fedimintd>

vars: BTreeMap<usize, Fedimintd>

bitcoind: Bitcoind

client: JitTryAnyhow<Client>

Built in Client, already joined

connectors: ConnectorRegistry

Implementations

impl Federation

pub async fn new( process_mgr: &ProcessManager, bitcoind: Bitcoind, skip_setup: bool, pre_dkg: bool, pre_restore: bool, fed_index: usize, federation_name: String, ) -> Result<Self>

async fn restart_guardian_for_manual_restore( process_mgr: &ProcessManager, members: &mut BTreeMap<usize, Fedimintd>, peer_to_env_vars_map: &BTreeMap<usize, Fedimintd>, bitcoind: &Bitcoind, ) -> Result<()>

async fn write_guardian_backup_tar( data_dir: &Path, backup_path: &Path, ) -> Result<()>

pub fn client_config(&self) -> Result<ClientConfig>

pub fn module_instance_id_by_kind( &self, kind: &ModuleKind, ) -> Result<ModuleInstanceId>

Get the module instance ID for a given module kind

pub fn module_client_config<M: ClientModule>( &self, ) -> Result<Option<<M::Common as ModuleCommon>::ClientConfig>>

pub fn deposit_fees(&self) -> Result<Amount>

pub fn invite_code(&self) -> Result<String>

Read the invite code from the client data dir

pub fn invite_code_static() -> Result<String>

pub fn invite_code_for(peer_id: PeerId) -> Result<String>

pub async fn internal_client(&self) -> Result<&Client>

Built-in, default, internal Client

We should be moving away from using it for anything.

pub async fn new_joined_client(&self, name: impl ToString) -> Result<Client>

New Client that already joined self

pub async fn add_lnv2_gateway(&self, gateway: &str) -> Result<()>

Add a gateway to every guardian’s list of lnv2 gateways.

Clients only see lnv2 gateways that guardians have added via the authenticated lnv2 admin endpoint. Devimint has no human guardians, so this calls that endpoint with the well-known test credentials for each running guardian.

pub async fn start_server( &mut self, process_mgr: &ProcessManager, peer: usize, ) -> Result<()>

pub async fn terminate_server(&mut self, peer_id: usize) -> Result<()>

pub async fn await_server_terminated(&mut self, peer_id: usize) -> Result<()>

pub async fn start_all_servers( &mut self, process_mgr: &ProcessManager, ) -> Result<()>

Starts all peers not currently running.

pub async fn terminate_all_servers(&mut self) -> Result<()>

Terminates all running peers.

pub async fn restart_all_staggered_with_bin( &mut self, process_mgr: &ProcessManager, bin_path: &PathBuf, ) -> Result<()>

Coordinated shutdown of all peers that restart using the provided bin_path. Returns Ok() once all peers are online.

Staggering the restart more closely simulates upgrades in the wild.

pub async fn restart_all_with_bin( &mut self, process_mgr: &ProcessManager, bin_path: &PathBuf, ) -> Result<()>

pub async fn degrade_federation( &mut self, process_mgr: &ProcessManager, ) -> Result<()>

pub async fn send_to_address(&self, address: String, amount: u64) -> Result<()>

pub async fn pegin_client_no_wait( &self, amount: u64, client: &Client, ) -> Result<String>

pub async fn pegin_client(&self, amount: u64, client: &Client) -> Result<()>

pub async fn pegin_gateways( &self, amount: u64, gateways: Vec<&Gatewayd>, ) -> Result<()>

Initiates multiple peg-ins to the same federation for the set of gateways to save on mining blocks in parallel.

pub async fn pegout_gateways( &self, amount: u64, gateways: Vec<&Gatewayd>, ) -> Result<()>

Initiates multiple peg-outs from the same federation for the set of gateways to save on mining blocks in parallel.

pub fn calculate_federation_id(&self) -> String

pub async fn await_block_sync(&self) -> Result<u64>

fn get_finality_delay(&self) -> Result<u32, Error>

pub async fn await_gateways_registered(&self) -> Result<()>

pub async fn await_all_peers(&self) -> Result<()>

pub async fn await_peer(&self, peer_id: usize) -> Result<()>

pub async fn finalize_mempool_tx(&self) -> Result<()>

Mines enough blocks to finalize mempool transactions, then waits for federation to process finalized blocks.

ex: tx submitted to mempool at height 100 finality delay = 10 mine finality delay blocks + 1 => new height 111 tx included in block 101 highest finalized height = 111 - 10 = 101

pub async fn mine_then_wait_blocks_sync(&self, blocks: u64) -> Result<()>

pub fn num_members(&self) -> usize

pub fn member_ids(&self) -> impl Iterator<Item = PeerId> + '_

Trait Implementations

impl Clone for Federation

fn clone(&self) -> Federation

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Drop for Federation

fn drop(&mut self)

Executes the destructor for this type.