Struct Federation

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

Fields

members: BTreeMap<usize, Fedimintd>

vars: BTreeMap<usize, Fedimintd>

bitcoind: Bitcoind

client: JitTryAnyhow<Client>

Built in Client, already joined

Implementations

impl Federation

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

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

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 start_server( &mut self, process_mgr: &ProcessManager, peer: usize, ) -> Result<()>

pub async fn terminate_server(&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_after_session( &mut self, process_mgr: &ProcessManager, bin_path: &PathBuf, ) -> Result<()>

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

fn version_requires_coordinated_shutdown(version: &Version) -> bool

pub async fn degrade_federation( &mut self, process_mgr: &ProcessManager, ) -> 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<()>

Inititates 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 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 copy 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.