Struct ClientBuilder

pub struct ClientBuilder {
    module_inits: ClientModuleInitRegistry,
    primary_module_instance: Option<ModuleInstanceId>,
    primary_module_kind: Option<ModuleKind>,
    admin_creds: Option<AdminCreds>,
    db_no_decoders: Database,
    meta_service: Arc<MetaService>,
    connector: Connector,
    stopped: bool,
    log_event_added_transient_tx: Sender<EventLogEntry>,
    request_hook: ApiRequestHook,
}

Used to configure, assemble and build Client

Fields

module_inits: ClientModuleInitRegistry

primary_module_instance: Option<ModuleInstanceId>

primary_module_kind: Option<ModuleKind>

admin_creds: Option<AdminCreds>

db_no_decoders: Database

meta_service: Arc<MetaService>

connector: Connector

stopped: bool

log_event_added_transient_tx: Sender<EventLogEntry>

request_hook: ApiRequestHook

Implementations

impl ClientBuilder

pub(crate) fn new(db: Database) -> Self

pub(crate) fn from_existing(client: &Client) -> Self

pub fn with_module_inits(&mut self, module_inits: ClientModuleInitRegistry)

Replace module generator registry entirely

There has to be at least one module supporting being primary among the registered modules. The client won’t start without the federation and the client having at least one overlapping primary module. In case there are multiple, the one to use can be selected with ClientBuilder::with_primary_module_kind or ClientBuilder::with_primary_module_instance_id.

pub fn with_module<M: ClientModuleInit>(&mut self, module_init: M)

Make module generator available when reading the config

There has to be at least one module supporting being primary among the registered modules. The client won’t start without the federation and the client having at least one overlapping primary module. In case there are multiple, the one to use can be selected with ClientBuilder::with_primary_module_kind or ClientBuilder::with_primary_module_instance_id.

pub fn stopped(&mut self)

pub fn with_api_request_hook(self, hook: ApiRequestHook) -> Self

Build the Client with a custom wrapper around its api request logic

This is intended to be used by downstream applications, e.g. to:

• simulate offline mode,
• save battery when the OS indicates lack of connectivity,
• inject faults and delays for testing purposes,
• collect statistics and emit notifications.

pub fn with_primary_module(&mut self, primary_module_instance: ModuleInstanceId)

👎Deprecated since 0.6.0: Use with_primary_module_kind instead, as the instance id can’t be known upfront. If you really need the old behavior you can use with_primary_module_instance_id.

Uses this module with the given instance id as the primary module. See fedimint_client_module::ClientModule::supports_being_primary for more information.

Panics

If there was a primary module specified previously

pub fn with_primary_module_instance_id( &mut self, primary_module_instance: ModuleInstanceId, )

You are likely looking for ClientBuilder::with_primary_module_kind. This function is rarely useful and often dangerous, handle with care.

Uses this module with the given instance id as the primary module. See fedimint_client_module::ClientModule::supports_being_primary for more information. Since the module instance id of modules of a specific kind may differ between different federations it is generally not recommended to specify it, but rather to specify the module kind that should be used as primary. See ClientBuilder::with_primary_module_kind.

Panics

If there was a primary module specified previously

pub fn with_primary_module_kind(&mut self, primary_module_kind: ModuleKind)

Uses this module kind as the primary module if present in the config. See fedimint_client_module::ClientModule::supports_being_primary for more information.

Panics

If there was a primary module kind specified previously

pub fn with_meta_service(&mut self, meta_service: Arc<MetaService>)

async fn migrate_module_dbs(&self, db: &Database) -> Result<()>

Migrate client module databases

Note: Client core db migration are done immediately in Client::builder, to ensure db matches the code at all times, while migrating modules requires figuring out what modules actually are first.

pub fn db_no_decoders(&self) -> &Database

pub async fn load_existing_config(&self) -> Result<ClientConfig>

pub fn set_admin_creds(&mut self, creds: AdminCreds)

pub fn with_connector(&mut self, connector: Connector)

pub fn with_tor_connector(&mut self)

async fn init( self, pre_root_secret: DerivableSecret, config: ClientConfig, api_secret: Option<String>, init_mode: InitMode, ) -> Result<ClientHandle>

pub async fn preview(self, invite_code: &InviteCode) -> Result<ClientPreview>

pub async fn preview_with_existing_config( self, config: ClientConfig, api_secret: Option<String>, ) -> Result<ClientPreview>

Use Self::preview instead

async fn download_backup_from_federation( &self, pre_root_secret: DerivableSecret, config: &ClientConfig, api_secret: Option<String>, ) -> Result<Option<ClientBackup>>

Download most recent valid backup found from the Federation

pub async fn open(self, pre_root_secret: RootSecret) -> Result<ClientHandle>

pub(crate) async fn build( self, pre_root_secret: DerivableSecret, config: ClientConfig, api_secret: Option<String>, stopped: bool, ) -> Result<ClientHandle>

Build a Client and start the executor

async fn build_stopped( self, pre_root_secret: DerivableSecret, config: &ClientConfig, api_secret: Option<String>, log_event_added_transient_tx: Sender<EventLogEntry>, request_hook: ApiRequestHook, ) -> Result<ClientHandle>

Build a Client but do not start the executor

async fn load_init_state(db: &Database) -> InitState

fn decoders(&self, config: &ClientConfig) -> ModuleDecoderRegistry

fn config_decoded( config: &ClientConfig, decoders: &ModuleDecoderRegistry, ) -> Result<ClientConfig, DecodeError>

fn federation_root_secret( pre_root_secret: &DerivableSecret, config: &ClientConfig, ) -> DerivableSecret

Re-derive client’s root_secret using the federation ID. This eliminates the possibility of having the same client root_secret across multiple federations.

pub fn get_event_log_transient_receiver(&self) -> Receiver<EventLogEntry>

Register to receiver all new transient (unpersisted) events