Function handle_command

src/handlers.rs:1199–1439

The global top level handler.

(cli_opts: CliOpts)

/// The global top level handler.
pub(crate) async fn handle_command(cli_opts: CliOpts) -> Result<String, Error> {
    let pretty = cli_opts.pretty;
    let subcommand = cli_opts.subcommand.clone();

    let result: Result<String, Error> = match subcommand {
        #[cfg(any(
            feature = "electrum",
            feature = "esplora",
            feature = "cbf",
            feature = "rpc"
        ))]
        CliSubCommand::Wallet {
            wallet,
            subcommand: WalletSubCommand::OnlineWalletSubCommand(online_subcommand),
        } => {
            let home_dir = prepare_home_dir(cli_opts.datadir)?;

            let (wallet_opts, network) = load_wallet_config(&home_dir, &wallet)?;

            let database_path = prepare_wallet_db_dir(&home_dir, &wallet)?;

            #[cfg(any(feature = "sqlite", feature = "redb"))]
            let result = {
                let mut persister: Persister = match &wallet_opts.database_type {
                    #[cfg(feature = "sqlite")]
                    DatabaseType::Sqlite => {
                        let db_file = database_path.join("wallet.sqlite");
                        let connection = Connection::open(db_file)?;
                        log::debug!("Sqlite database opened successfully");
                        Persister::Connection(connection)
                    }
                    #[cfg(feature = "redb")]
                    DatabaseType::Redb => {
                        let wallet_name = &wallet_opts.wallet;
                        let db = Arc::new(bdk_redb::redb::Database::create(
                            home_dir.join("wallet.redb"),
                        )?);
                        let store = RedbStore::new(
                            db,
                            wallet_name.as_deref().unwrap_or("wallet").to_string(),
                        )?;
                        log::debug!("Redb database opened successfully");
                        Persister::RedbStore(store)
                    }
                };

                let mut wallet = new_persisted_wallet(network, &mut persister, &wallet_opts)?;
                let blockchain_client =
                    new_blockchain_client(&wallet_opts, &wallet, database_path)?;

                let result = handle_online_wallet_subcommand(
                    &mut wallet,
                    &blockchain_client,
                    online_subcommand,
                )
                .await?;
                wallet.persist(&mut persister)?;
                result