251    bool isLockedCoin(const COutPoint& output) override
252    {
253        LOCK(m_wallet->cs_wallet);
254        return m_wallet->IsLockedCoin(output);
255    }
256    void listLockedCoins(std::vector<COutPoint>& outputs) override
257    {
258        LOCK(m_wallet->cs_wallet);
259        return m_wallet->ListLockedCoins(outputs);
260    }
261    util::Result<wallet::CreatedTransactionResult> createTransaction(const std::vector<CRecipient>& recipients,
262        const CCoinControl& coin_control,
263        bool sign,
264        std::optional<unsigned int> change_pos) override
265    {
266        LOCK(m_wallet->cs_wallet);
267        return CreateTransaction(*m_wallet, recipients, change_pos, coin_control, sign);
268    }
269    void commitTransaction(CTransactionRef tx, const std::vector<std::string>& messages) override
270    {
271        LOCK(m_wallet->cs_wallet);
272        m_wallet->CommitTransaction(std::move(tx), /*replaces_txid=*/std::nullopt, /*comment=*/std::nullopt, /*comment_to=*/std::nullopt, messages);
273    }
274    bool transactionCanBeAbandoned(const Txid& txid) override { return m_wallet->TransactionCanBeAbandoned(txid); }
275    bool abandonTransaction(const Txid& txid) override
276    {
277        LOCK(m_wallet->cs_wallet);
278        return m_wallet->AbandonTransaction(txid);
279    }
280    bool transactionCanBeBumped(const Txid& txid) override
281    {
282        return feebumper::TransactionCanBeBumped(*m_wallet.get(), txid);
283    }
284    bool createBumpTransaction(const Txid& txid,
285        const CCoinControl& coin_control,
286        std::vector<bilingual_str>& errors,
287        CAmount& old_fee,
288        CAmount& new_fee,
289        CMutableTransaction& mtx) override
290    {
291        std::vector<CTxOut> outputs; // just an empty list of new recipients for now
292        return feebumper::CreateRateBumpTransaction(*m_wallet.get(), txid, coin_control, errors, old_fee, new_fee, mtx, /* require_mine= */ true, outputs) == feebumper::Result::OK;
293    }
294    bool signBumpTransaction(CMutableTransaction& mtx) override { return feebumper::SignTransaction(*m_wallet.get(), mtx); }
295    bool commitBumpTransaction(const Txid& txid,
296        CMutableTransaction&& mtx,
297        std::vector<bilingual_str>& errors,
298        Txid& bumped_txid) override
299    {
300        return feebumper::CommitTransaction(*m_wallet.get(), txid, std::move(mtx), errors, bumped_txid) ==
301               feebumper::Result::OK;
302    }
303    CTransactionRef getTx(const Txid& txid) override
304    {
305        LOCK(m_wallet->cs_wallet);
306        auto mi = m_wallet->mapWallet.find(txid);
307        if (mi != m_wallet->mapWallet.end()) {
308            return mi->second.GetTx();
309        }
310        return {};
311    }
312    WalletTx getWalletTx(const Txid& txid) override
313    {
314        LOCK(m_wallet->cs_wallet);
315        auto mi = m_wallet->mapWallet.find(txid);
316        if (mi != m_wallet->mapWallet.end()) {
317            return MakeWalletTx(*m_wallet, mi->second);
318        }
319        return {};
320    }
321    std::set<WalletTx> getWalletTxs() override
322    {
323        LOCK(m_wallet->cs_wallet);
324        std::set<WalletTx> result;
325        for (const auto& entry : m_wallet->mapWallet) {
326            result.emplace(MakeWalletTx(*m_wallet, entry.second));
327        }
328        return result;
329    }
330    bool tryGetTxStatus(const Txid& txid,
331        interfaces::WalletTxStatus& tx_status,
332        int& num_blocks,
333        int64_t& block_time) override
334    {
335        TRY_LOCK(m_wallet->cs_wallet, locked_wallet);
336        if (!locked_wallet) {
337            return false;
338        }
339        auto mi = m_wallet->mapWallet.find(txid);
340        if (mi == m_wallet->mapWallet.end()) {
341            return false;
342        }
343        num_blocks = m_wallet->GetLastBlockHeight();
344        block_time = -1;
345        CHECK_NONFATAL(m_wallet->chain().findBlock(m_wallet->GetLastBlockHash(), FoundBlock().time(block_time)));
346        tx_status = MakeWalletTxStatus(*m_wallet, mi->second);
347        return true;
348    }
349    WalletTx getWalletTxDetails(const Txid& txid,
350        WalletTxStatus& tx_status,
351        std::vector<std::string>& messages,
352        std::vector<std::string>& payment_requests,
353        bool& in_mempool,
354        int& num_blocks) override
355    {
356        LOCK(m_wallet->cs_wallet);
357        auto mi = m_wallet->mapWallet.find(txid);
358        if (mi != m_wallet->mapWallet.end()) {
359            num_blocks = m_wallet->GetLastBlockHeight();
360            in_mempool = mi->second.InMempool();
361            messages = mi->second.m_messages;
362            payment_requests = mi->second.m_payment_requests;
363            tx_status = MakeWalletTxStatus(*m_wallet, mi->second);
364            return MakeWalletTx(*m_wallet, mi->second);
365        }
366        return {};
367    }
368    std::optional<PSBTError> fillPSBT(const common::PSBTFillOptions& options,
369        size_t* n_signed,
370        PartiallySignedTransaction& psbtx,
371        bool& complete) override
372    {
373        return m_wallet->FillPSBT(psbtx, options, complete, n_signed);
374    }
375    WalletBalances getBalances() override
376    {
377        const auto bal = GetBalance(*m_wallet);
378        WalletBalances result;
379        result.balance = bal.m_mine_trusted;
380        result.unconfirmed_balance = bal.m_mine_untrusted_pending;
381        result.immature_balance = bal.m_mine_immature;
382        result.used_balance = bal.m_mine_used;
383        result.nonmempool_balance = bal.m_mine_nonmempool;
384        return result;
385    }
386    bool tryGetBalances(WalletBalances& balances, uint256& block_hash) override
387    {
388        TRY_LOCK(m_wallet->cs_wallet, locked_wallet);
389        if (!locked_wallet) {
390            return false;
391        }
392        block_hash = m_wallet->GetLastBlockHash();
393        balances = getBalances();
394        return true;
395    }
396    CAmount getBalance() override { return GetBalance(*m_wallet).m_mine_trusted; }
397    CAmount getAvailableBalance(const CCoinControl& coin_control) override
398    {
399        LOCK(m_wallet->cs_wallet);
400        CAmount total_amount = 0;
401        // Fetch selected coins total amount
402        if (coin_control.HasSelected()) {
403            FastRandomContext rng{};
404            CoinSelectionParams params(rng);
405            // Note: for now, swallow any error.
406            if (auto res = FetchSelectedInputs(*m_wallet, coin_control, params)) {
407                total_amount += res->GetTotalAmount();
408            }
409        }
410
411        // And fetch the wallet available coins
412        if (coin_control.m_allow_other_inputs) {
413            total_amount += AvailableCoins(*m_wallet, &coin_control).GetTotalAmount();
414        }
415
416        return total_amount;
417    }
418    bool txinIsMine(const CTxIn& txin) override
419    {
420        LOCK(m_wallet->cs_wallet);
421        return InputIsMine(*m_wallet, txin);
422    }
423    bool txoutIsMine(const CTxOut& txout) override
424    {
425        LOCK(m_wallet->cs_wallet);
426        return m_wallet->IsMine(txout);
427    }
428    CAmount getDebit(const CTxIn& txin) override
429    {
430        LOCK(m_wallet->cs_wallet);
431        return m_wallet->GetDebit(txin);
432    }
433    CAmount getCredit(const CTxOut& txout) override
434    {
435        LOCK(m_wallet->cs_wallet);
436        return OutputGetCredit(*m_wallet, txout);
437    }
438    CoinsList listCoins() override
439    {
440        LOCK(m_wallet->cs_wallet);
441        CoinsList result;
442        for (const auto& entry : ListCoins(*m_wallet)) {
443            auto& group = result[entry.first];
444            for (const auto& coin : entry.second) {
445                group.emplace_back(coin.outpoint,
446                    MakeWalletTxOut(*m_wallet, coin));
447            }
448        }
449        return result;
450    }
451    std::vector<WalletTxOut> getCoins(const std::vector<COutPoint>& outputs) override
452    {
453        LOCK(m_wallet->cs_wallet);
454        std::vector<WalletTxOut> result;
455        result.reserve(outputs.size());
456        for (const auto& output : outputs) {
457            result.emplace_back();
458            auto it = m_wallet->mapWallet.find(output.hash);
459            if (it != m_wallet->mapWallet.end()) {
460                int depth = m_wallet->GetTxDepthInMainChain(it->second);
461                if (depth >= 0) {
462                    result.back() = MakeWalletTxOut(*m_wallet, it->second, output.n, depth);
463                }
464            }
465        }
466        return result;
467    }
468    CAmount getRequiredFee(unsigned int tx_bytes) override { return GetRequiredFee(*m_wallet, tx_bytes); }
469    CAmount getMinimumFee(unsigned int tx_bytes,
470        const CCoinControl& coin_control,
471        std::optional<int>* returned_target,
472        FeeReason* reason) override
473    {
474        auto min_fee_rate{GetMinimumFeeRate(*m_wallet, coin_control)};
475        auto result = GetMinimumFee(min_fee_rate, tx_bytes);
476        if (returned_target) *returned_target = min_fee_rate.returned_target;
477        if (reason) *reason = min_fee_rate.fee_reason;
478        return result;
479    }
480    unsigned int getConfirmTarget() override { return m_wallet->m_confirm_target; }
481    bool hdEnabled() override { return m_wallet->IsHDEnabled(); }
482    bool canGetAddresses() override { return m_wallet->CanGetAddresses(); }
483    bool hasExternalSigner() override { return m_wallet->IsWalletFlagSet(WALLET_FLAG_EXTERNAL_SIGNER); }
484    bool privateKeysDisabled() override { return m_wallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS); }
485    bool taprootEnabled() override {
486        auto spk_man = m_wallet->GetScriptPubKeyMan(OutputType::BECH32M, /*internal=*/false);
487        return spk_man != nullptr;
488    }
489    OutputType getDefaultAddressType() override { return m_wallet->m_default_address_type; }
490    CAmount getDefaultMaxTxFee() override { return m_wallet->m_default_max_tx_fee; }
491    void remove() override
492    {
493        RemoveWallet(m_context, m_wallet, /*load_on_start=*/false);
494    }
495    std::unique_ptr<Handler> handleUnload(UnloadFn fn) override
496    {
497        return MakeSignalHandler(m_wallet->NotifyUnload.connect(fn));
498    }
499    std::unique_ptr<Handler> handleShowProgress(ShowProgressFn fn) override
500    {