Struct ClientPreview 

pub struct ClientPreview {
    inner: ClientBuilder,
    config: ClientConfig,
    api_secret: Option<String>,
    prefetch_api_announcements: Option<Jit<Vec<BTreeMap<PeerId, SignedApiAnnouncement>>>>,
    preview_prefetch_api_version_set: Option<JitTryAnyhow<BTreeMap<PeerId, SupportedApiVersionsSummary>>>,
}

Fields

inner: ClientBuilder

config: ClientConfig

api_secret: Option<String>

prefetch_api_announcements: Option<Jit<Vec<BTreeMap<PeerId, SignedApiAnnouncement>>>>

preview_prefetch_api_version_set: Option<JitTryAnyhow<BTreeMap<PeerId, SupportedApiVersionsSummary>>>

Implementations

impl ClientPreview

pub fn config(&self) -> &ClientConfig

Get the config

pub async fn join( self, db_no_decoders: Database, pre_root_secret: RootSecret, ) -> Result<ClientHandle>

Join a new Federation

When a user wants to connect to a new federation this function fetches the federation config and initializes the client database. If a user already joined the federation in the past and has a preexisting database use ClientBuilder::open instead.

Warning: Calling join with a root_secret key that was used previous to join a Federation will lead to all sorts of malfunctions including likely loss of funds.

This should be generally called only if the root_secret key is known not to have been used before (e.g. just randomly generated). For keys that might have been previous used (e.g. provided by the user), it’s safer to call Self::recover which will attempt to recover client module states for the Federation.

A typical “join federation” flow would look as follows:

// Create a root secret, e.g. via fedimint-bip39, see also:
// https://github.com/fedimint/fedimint/blob/master/docs/secret_derivation.md
// let root_secret = …;

// Get invite code from user
let invite_code = InviteCode::from_str("fed11qgqpw9thwvaz7te3xgmjuvpwxqhrzw3jxumrvvf0qqqjpetvlg8glnpvzcufhffgzhv8m75f7y34ryk7suamh8x7zetly8h0v9v0rm")
    .expect("Invalid invite code");

// Tell the user the federation name, bitcoin network
// (e.g. from wallet module config), and other details
// that are typically contained in the federation's
// meta fields.

// let network = config.get_first_module_by_kind::<WalletClientConfig>("wallet")
//     .expect("Module not found")
//     .network;

// Open the client's database, using the federation ID
// as the DB name is a common pattern:

// let db_path = format!("./path/to/db/{}", config.federation_id());
// let db = RocksDb::open(db_path).expect("error opening DB");

let preview = Client::builder().await
    // Mount the modules the client should support:
    // .with_module(LightningClientInit)
    // .with_module(MintClientInit)
    // .with_module(WalletClientInit::default())
     .expect("Error building client")
     .preview(&invite_code).await?;

println!(
    "The federation name is: {}",
    preview.config().meta::<String>(META_FEDERATION_NAME_KEY)
        .expect("Could not decode name field")
        .expect("Name isn't set")
);

let client = preview
    .join(db, RootSecret::StandardDoubleDerive(root_secret))
    .await
    .expect("Error joining federation");

pub async fn recover( self, db_no_decoders: Database, pre_root_secret: RootSecret, backup: Option<ClientBackup>, ) -> Result<ClientHandle>

Join a (possibly) previous joined Federation

Unlike Self::join, recover will run client module recovery for each client module attempting to recover any previous module state.

Recovery process takes time during which each recovering client module will not be available for use.

Calling recovery with a root_secret that was not actually previous used in a given Federation is safe.

pub async fn download_backup_from_federation( &self, pre_root_secret: RootSecret, ) -> Result<Option<ClientBackup>>

Download most recent valid backup found from the Federation