501        return MakeSignalHandler(m_wallet->ShowProgress.connect(fn));
502    }
503    std::unique_ptr<Handler> handleStatusChanged(StatusChangedFn fn) override
504    {
505        return MakeSignalHandler(m_wallet->NotifyStatusChanged.connect([fn](CWallet*) { fn(); }));
506    }
507    std::unique_ptr<Handler> handleAddressBookChanged(AddressBookChangedFn fn) override
508    {
509        return MakeSignalHandler(m_wallet->NotifyAddressBookChanged.connect(
510            [fn](const CTxDestination& address, const std::string& label, bool is_mine,
511                 AddressPurpose purpose, ChangeType status) { fn(address, label, is_mine, purpose, status); }));
512    }
513    std::unique_ptr<Handler> handleTransactionChanged(TransactionChangedFn fn) override
514    {
515        return MakeSignalHandler(m_wallet->NotifyTransactionChanged.connect(
516            [fn](const Txid& txid, ChangeType status) { fn(txid, status); }));
517    }
518    std::unique_ptr<Handler> handleCanGetAddressesChanged(CanGetAddressesChangedFn fn) override
519    {
520        return MakeSignalHandler(m_wallet->NotifyCanGetAddressesChanged.connect(fn));
521    }
522    CWallet* wallet() override { return m_wallet.get(); }
523
524    util::Result<std::string> exportWatchOnlyWallet(const fs::path& destination) override {
525        LOCK(m_wallet->cs_wallet);
526        m_wallet->TopUpKeyPool();
527        return ExportWatchOnlyWallet(*m_wallet, destination, m_context);
528    }
529
530    WalletContext& m_context;
531    std::shared_ptr<CWallet> m_wallet;
532};
533
534class WalletLoaderImpl : public WalletLoader
535{
536public:
537    WalletLoaderImpl(Chain& chain, ArgsManager& args)
538    {
539        m_context.chain = &chain;
540        m_context.args = &args;
541    }
542    ~WalletLoaderImpl() override { stop(); }
543
544    //! ChainClient methods
545    void registerRpcs() override
546    {
547        for (const CRPCCommand& command : GetWalletRPCCommands()) {
548            m_rpc_commands.emplace_back(command.category, command.name, [this, &command](const JSONRPCRequest& request, UniValue& result, bool last_handler) {
549                JSONRPCRequest wallet_request = request;
550                wallet_request.context = &m_context;
551                return command.actor(wallet_request, result, last_handler);
552            }, command.argNames, command.unique_id);
553            m_rpc_commands.back().metadata_fn = command.metadata_fn;
554            m_rpc_handlers.emplace_back(m_context.chain->handleRpc(m_rpc_commands.back()));
555        }
556    }
557    bool verify() override { return VerifyWallets(m_context); }
558    bool load() override { return LoadWallets(m_context); }
559    void start(CScheduler& scheduler) override
560    {
561        m_context.scheduler = &scheduler;
562        return StartWallets(m_context);
563    }
564    void stop() override { return UnloadWallets(m_context); }
565    void setMockTime(int64_t time) override { return SetMockTime(std::chrono::seconds{time}); }
566    void schedulerMockForward(std::chrono::seconds delta) override { Assert(m_context.scheduler)->MockForward(delta); }
567
568    //! WalletLoader methods
569    util::Result<std::unique_ptr<Wallet>> createWallet(const std::string& name, const SecureString& passphrase, uint64_t wallet_creation_flags, std::vector<bilingual_str>& warnings) override
570    {
571        DatabaseOptions options;
572        DatabaseStatus status;
573        ReadDatabaseArgs(*m_context.args, options);
574        options.require_create = true;
575        options.create_flags = wallet_creation_flags;
576        options.create_passphrase = passphrase;
577        bilingual_str error;
578        std::unique_ptr<Wallet> wallet{MakeWallet(m_context, CreateWallet(m_context, name, /*load_on_start=*/true, options, status, error, warnings))};
579        if (wallet) {
580            return wallet;
581        } else {
582            return util::Error{error};
583        }
584    }
585    util::Result<std::unique_ptr<Wallet>> loadWallet(const std::string& name, std::vector<bilingual_str>& warnings) override
586    {
587        DatabaseOptions options;
588        DatabaseStatus status;
589        ReadDatabaseArgs(*m_context.args, options);
590        options.require_existing = true;
591        bilingual_str error;
592        std::unique_ptr<Wallet> wallet{MakeWallet(m_context, LoadWallet(m_context, name, /*load_on_start=*/true, options, status, error, warnings))};
593        if (wallet) {
594            return wallet;
595        } else {
596            return util::Error{error};
597        }
598    }
599    util::Result<std::unique_ptr<Wallet>> restoreWallet(const fs::path& backup_file, const std::string& wallet_name, std::vector<bilingual_str>& warnings, bool load_after_restore) override
600    {
601        DatabaseStatus status;
602        bilingual_str error;
603        std::unique_ptr<Wallet> wallet{MakeWallet(m_context, RestoreWallet(m_context, backup_file, wallet_name, /*load_on_start=*/true, status, error, warnings, load_after_restore))};
604        if (!error.empty()) {
605            return util::Error{error};
606        }
607        return wallet;
608    }
609    util::Result<WalletMigrationResult> migrateWallet(const std::string& name, const SecureString& passphrase, bool load_wallet) override
610    {
611        auto res = wallet::MigrateLegacyToDescriptor(name, passphrase, m_context, load_wallet);
612        if (!res) return util::Error{util::ErrorString(res)};
613        WalletMigrationResult out{
614            .wallet = MakeWallet(m_context, res->wallet),
615            .watchonly_wallet_name = res->watchonly_wallet_name,
616            .solvables_wallet_name = res->solvables_wallet_name,
617            .backup_path = res->backup_path,
618        };
619        return out;
620    }
621    bool isEncrypted(const std::string& wallet_name) override
622    {
623        auto wallets{GetWallets(m_context)};
624        auto it = std::find_if(wallets.begin(), wallets.end(), [&](std::shared_ptr<CWallet> w){ return w->GetName() == wallet_name; });
625        if (it != wallets.end()) return (*it)->HasEncryptionKeys();
626
627        // Unloaded wallet, read db
628        DatabaseOptions options;
629        options.require_existing = true;
630        DatabaseStatus status;
631        bilingual_str error;
632        auto db = MakeWalletDatabase(wallet_name, options, status, error);
633        if (!db && status == wallet::DatabaseStatus::FAILED_LEGACY_DISABLED) {
634            options.require_format = wallet::DatabaseFormat::BERKELEY_RO;
635            db = MakeWalletDatabase(wallet_name, options, status, error);
636        }
637        if (!db) return false;
638        return WalletBatch(*db).IsEncrypted();
639    }
640    std::string getWalletDir() override
641    {
642        return fs::PathToString(GetWalletDir());
643    }
644    std::vector<std::pair<std::string, std::string>> listWalletDir() override
645    {
646        std::vector<std::pair<std::string, std::string>> paths;
647        for (auto& [path, format] : ListDatabases(GetWalletDir())) {
648            paths.emplace_back(fs::PathToString(path), format);
649        }
650        return paths;
651    }
652    std::vector<std::unique_ptr<Wallet>> getWallets() override
653    {
654        std::vector<std::unique_ptr<Wallet>> wallets;
655        for (const auto& wallet : GetWallets(m_context)) {
656            wallets.emplace_back(MakeWallet(m_context, wallet));
657        }
658        return wallets;
659    }
660    std::unique_ptr<Handler> handleLoadWallet(LoadWalletFn fn) override
661    {
662        return HandleLoadWallet(m_context, std::move(fn));
663    }
664    WalletContext* context() override  { return &m_context; }
665
666    WalletContext m_context;
667    const std::vector<std::string> m_wallet_filenames;
668    std::vector<std::unique_ptr<Handler>> m_rpc_handlers;
669    std::list<CRPCCommand> m_rpc_commands;
670};
671} // namespace
672} // namespace wallet
673
674namespace interfaces {
675std::unique_ptr<Wallet> MakeWallet(wallet::WalletContext& context, const std::shared_ptr<wallet::CWallet>& wallet) { return wallet ? std::make_unique<wallet::WalletImpl>(context, wallet) : nullptr; }
676
677std::unique_ptr<WalletLoader> MakeWalletLoader(Chain& chain, ArgsManager& args)
678{
679    return std::make_unique<wallet::WalletLoaderImpl>(chain, args);
680}
681} // namespace interfaces
682