wallet: split off ListProTxCoins to allow supplying your own set

kwvg · kwvg · commit eb9ee696b6fc · 2025-01-27T10:09:03.000Z
Plus clean up `ListLockedCoins` a bit...
diff --git a/src/interfaces/wallet.h b/src/interfaces/wallet.h
@@ -145,10 +145,10 @@ class Wallet
     virtual bool isLockedCoin(const COutPoint& output) = 0;
 
     //! List locked coins.
-    virtual void listLockedCoins(std::vector<COutPoint>& outputs) = 0;
+    virtual std::vector<COutPoint> listLockedCoins() = 0;
 
     //! List protx coins.
-    virtual void listProTxCoins(std::vector<COutPoint>& vOutpts) = 0;
+    virtual std::vector<COutPoint> listProTxCoins() = 0;
 
     //! Create transaction.
     virtual CTransactionRef createTransaction(const std::vector<CRecipient>& recipients,
diff --git a/src/qt/coincontroldialog.cpp b/src/qt/coincontroldialog.cpp
@@ -426,8 +426,7 @@ void CoinControlDialog::viewItemChanged(QTreeWidgetItem* item, int column)
 // shows count of locked unspent outputs
 void CoinControlDialog::updateLabelLocked()
 {
-    std::vector<COutPoint> vOutpts;
-    model->wallet().listLockedCoins(vOutpts);
+    std::vector<COutPoint> vOutpts{model->wallet().listLockedCoins()};
     if (vOutpts.size() > 0)
     {
        ui->labelLocked->setText(tr("(%1 locked)").arg(vOutpts.size()));
diff --git a/src/qt/masternodelist.cpp b/src/qt/masternodelist.cpp
@@ -204,9 +204,7 @@ void MasternodeList::updateDIP3List()
 
     std::set<COutPoint> setOutpts;
     if (walletModel && ui->checkBoxMyMasternodesOnly->isChecked()) {
-        std::vector<COutPoint> vOutpts;
-        walletModel->wallet().listProTxCoins(vOutpts);
-        for (const auto& outpt : vOutpts) {
+        for (const auto& outpt : walletModel->wallet().listProTxCoins()) {
             setOutpts.emplace(outpt);
         }
     }
diff --git a/src/rpc/evo.cpp b/src/rpc/evo.cpp
@@ -1390,10 +1390,8 @@ static RPCHelpMan protx_list()
             throw JSONRPCError(RPC_INVALID_PARAMETER, "invalid height specified");
         }
 
-        std::vector<COutPoint> vOutpts;
-        wallet->ListProTxCoins(vOutpts);
         std::set<COutPoint> setOutpts;
-        for (const auto& outpt : vOutpts) {
+        for (const auto& outpt : wallet->ListProTxCoins()) {
             setOutpts.emplace(outpt);
         }
 
diff --git a/src/wallet/interfaces.cpp b/src/wallet/interfaces.cpp
@@ -255,15 +255,13 @@ class WalletImpl : public Wallet
         LOCK(m_wallet->cs_wallet);
         return m_wallet->IsLockedCoin(output.hash, output.n);
     }
-    void listLockedCoins(std::vector<COutPoint>& outputs) override
+    std::vector<COutPoint> listLockedCoins() override
     {
-        LOCK(m_wallet->cs_wallet);
-        return m_wallet->ListLockedCoins(outputs);
+        return WITH_LOCK(m_wallet->cs_wallet, return m_wallet->ListLockedCoins());
     }
-    void listProTxCoins(std::vector<COutPoint>& outputs) override
+    std::vector<COutPoint> listProTxCoins() override
     {
-        LOCK(m_wallet->cs_wallet);
-        return m_wallet->ListProTxCoins(outputs);
+        return WITH_LOCK(m_wallet->cs_wallet, return m_wallet->ListProTxCoins());
     }
     CTransactionRef createTransaction(const std::vector<CRecipient>& recipients,
         const CCoinControl& coin_control,
diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp
@@ -2371,14 +2371,9 @@ static RPCHelpMan listlockunspent()
 
     LOCK(pwallet->cs_wallet);
 
-    std::vector<COutPoint> vOutpts;
-    pwallet->ListLockedCoins(vOutpts);
-
     UniValue ret(UniValue::VARR);
-
-    for (const COutPoint& outpt : vOutpts) {
+    for (const COutPoint& outpt : pwallet->ListLockedCoins()) {
         UniValue o(UniValue::VOBJ);
-
         o.pushKV("txid", outpt.hash.GetHex());
         o.pushKV("vout", (int)outpt.n);
         ret.push_back(o);
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
@@ -922,18 +922,16 @@ CWalletTx* CWallet::AddToWallet(CTransactionRef tx, const CWalletTx::Confirmatio
         wtx.nTimeSmart = ComputeTimeSmart(wtx);
         AddToSpends(hash, &batch);
 
-        std::vector<std::pair<const CTransactionRef&, unsigned int>> outputs;
-        for(unsigned int i = 0; i < wtx.tx->vout.size(); ++i) {
+        std::set<COutPoint> candidates;
+        for (unsigned int i = 0; i < wtx.tx->vout.size(); ++i) {
             if (IsMine(wtx.tx->vout[i]) && !IsSpent(hash, i)) {
                 setWalletUTXO.insert(COutPoint(hash, i));
-                outputs.emplace_back(wtx.tx, i);
+                candidates.emplace(hash, i);
             }
         }
         // TODO: refactor duplicated code between CWallet::AddToWallet and CWallet::AutoLockMasternodeCollaterals
-        if (m_chain) {
-            for (const auto& outPoint : m_chain->listMNCollaterials(outputs)) {
-                LockCoin(outPoint, &batch);
-            }
+        for (const auto& utxo : ListProTxCoins(candidates)) {
+            LockCoin(utxo, &batch);
         }
     }
 
@@ -951,21 +949,19 @@ CWalletTx* CWallet::AddToWallet(CTransactionRef tx, const CWalletTx::Confirmatio
             assert(wtx.m_confirm.block_height == confirm.block_height);
         }
 
-        std::vector<std::pair<const CTransactionRef&, unsigned int>> outputs;
-        for(unsigned int i = 0; i < wtx.tx->vout.size(); ++i) {
+        std::set<COutPoint> candidates;
+        for (unsigned int i = 0; i < wtx.tx->vout.size(); ++i) {
             if (IsMine(wtx.tx->vout[i]) && !IsSpent(hash, i)) {
                 bool new_utxo = setWalletUTXO.insert(COutPoint(hash, i)).second;
                 if (new_utxo) {
-                    outputs.emplace_back(wtx.tx, i);
+                    candidates.emplace(hash, i);
                     fUpdated = true;
                 }
             }
         }
         // TODO: refactor duplicated code with case fInstertedNew
-        if (m_chain) {
-            for (const auto& outPoint : m_chain->listMNCollaterials(outputs)) {
-                LockCoin(outPoint);
-            }
+        for (const auto& utxo : ListProTxCoins(candidates)) {
+            LockCoin(utxo, &batch);
         }
     }
 
@@ -2799,8 +2795,7 @@ std::map<CTxDestination, std::vector<COutput>> CWallet::ListCoins() const
         }
     }
 
-    std::vector<COutPoint> lockedCoins;
-    ListLockedCoins(lockedCoins);
+    std::vector<COutPoint> lockedCoins{ListLockedCoins()};
     // Include watch-only for LegacyScriptPubKeyMan wallets without private keys
     const bool include_watch_only = GetLegacyScriptPubKeyMan() && IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS);
     const isminetype is_mine_filter = include_watch_only ? ISMINE_WATCH_ONLY : ISMINE_SPENDABLE;
@@ -4056,20 +4051,18 @@ DBErrors CWallet::LoadWallet()
 // This avoids accidental spending of collaterals. They can still be unlocked manually if a spend is really intended.
 void CWallet::AutoLockMasternodeCollaterals()
 {
-    if (!m_chain) return;
-
-    std::vector<std::pair<const CTransactionRef&, unsigned int>> outputs;
-
     LOCK(cs_wallet);
-    for (const auto& pair : mapWallet) {
-        for (unsigned int i = 0; i < pair.second.tx->vout.size(); ++i) {
-            if (IsMine(pair.second.tx->vout[i]) && !IsSpent(pair.first, i)) {
-                outputs.emplace_back(pair.second.tx, i);
+    std::set<COutPoint> candidates;
+    for (const auto& [txid, wtx] : mapWallet) {
+        for (unsigned int i = 0; i < wtx.tx->vout.size(); ++i) {
+            if (IsMine(wtx.tx->vout[i]) && !IsSpent(txid, i)) {
+                candidates.emplace(txid, i);
             }
         }
     }
-    for (const auto& outPoint : m_chain->listMNCollaterials(outputs)) {
-        LockCoin(outPoint);
+    WalletBatch batch(GetDatabase());
+    for (const auto& utxo : ListProTxCoins(candidates)) {
+        LockCoin(utxo, &batch);
     }
 }
 
@@ -4502,34 +4495,32 @@ bool CWallet::IsLockedCoin(uint256 hash, unsigned int n) const
     return (setLockedCoins.count(outpt) > 0);
 }
 
-void CWallet::ListLockedCoins(std::vector<COutPoint>& vOutpts) const
+std::vector<COutPoint> CWallet::ListLockedCoins() const
 {
     AssertLockHeld(cs_wallet);
-    for (std::set<COutPoint>::iterator it = setLockedCoins.begin();
-         it != setLockedCoins.end(); it++) {
-        COutPoint outpt = (*it);
-        vOutpts.push_back(outpt);
+    std::vector<COutPoint> ret;
+    for (const auto& output : setLockedCoins) {
+        ret.push_back(output);
     }
+    return ret;
 }
 
-void CWallet::ListProTxCoins(std::vector<COutPoint>& vOutpts) const
-{
-    // TODO: refactor duplicated code between CWallet::AutoLockMasternodeCollaterals and CWallet::ListProTxCoins
-    if (!m_chain) {
-        vOutpts.clear();
-        return;
-    }
-    std::vector<std::pair<const CTransactionRef&, unsigned int>> outputs;
+std::vector<COutPoint> CWallet::ListProTxCoins() const { return ListProTxCoins(setWalletUTXO); }
 
+std::vector<COutPoint> CWallet::ListProTxCoins(const std::set<COutPoint>& utxos) const
+{
     AssertLockHeld(cs_wallet);
-    for (const auto &o : setWalletUTXO) {
-        auto it = mapWallet.find(o.hash);
-        if (it != mapWallet.end()) {
-            const auto &ptx = it->second;
-            outputs.emplace_back(ptx.tx, o.n);
+
+    if (!m_chain) return std::vector<COutPoint>();
+
+    std::vector<std::pair<const CTransactionRef&, unsigned int>> candidates;
+    for (const auto& output : utxos) {
+        if (auto it = mapWallet.find(output.hash); it != mapWallet.end()) {
+            const auto& [hash, wtx] = *it;
+            candidates.emplace_back(wtx.tx, output.n);
         }
     }
-    vOutpts = m_chain->listMNCollaterials(outputs);
+    return m_chain->listMNCollaterials(candidates);
 }
 
 /** @} */ // end of Actions
diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h
@@ -1038,8 +1038,9 @@ class CWallet final : public WalletStorage, public interfaces::Chain::Notificati
     bool LockCoin(const COutPoint& output, WalletBatch* batch = nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
     bool UnlockCoin(const COutPoint& output, WalletBatch* batch = nullptr) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
     bool UnlockAllCoins() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
-    void ListLockedCoins(std::vector<COutPoint>& vOutpts) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
-    void ListProTxCoins(std::vector<COutPoint>& vOutpts) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
+    std::vector<COutPoint> ListLockedCoins() const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
+    std::vector<COutPoint> ListProTxCoins() const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
+    std::vector<COutPoint> ListProTxCoins(const std::set<COutPoint>& utxos) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
     /*
      * Rescan abort properties

Original file line number	Diff line number	Diff line change
`@@ -426,8 +426,7 @@ void CoinControlDialog::viewItemChanged(QTreeWidgetItem* item, int column)`
`426`	`426`	`// shows count of locked unspent outputs`
`427`	`427`	`void CoinControlDialog::updateLabelLocked()`
`428`	`428`	`{`
`429`		`- std::vector<COutPoint> vOutpts;`
`430`		`- model->wallet().listLockedCoins(vOutpts);`
	`429`	`+ std::vector<COutPoint> vOutpts{model->wallet().listLockedCoins()};`
`431`	`430`	`if (vOutpts.size() > 0)`
`432`	`431`	`{`
`433`	`432`	`ui->labelLocked->setText(tr("(%1 locked)").arg(vOutpts.size()));`
Original file line number	Diff line number	Diff line change
`@@ -204,9 +204,7 @@ void MasternodeList::updateDIP3List()`
`204`	`204`
`205`	`205`	`std::set<COutPoint> setOutpts;`
`206`	`206`	`if (walletModel && ui->checkBoxMyMasternodesOnly->isChecked()) {`
`207`		`- std::vector<COutPoint> vOutpts;`
`208`		`- walletModel->wallet().listProTxCoins(vOutpts);`
`209`		`- for (const auto& outpt : vOutpts) {`
	`207`	`+ for (const auto& outpt : walletModel->wallet().listProTxCoins()) {`
`210`	`208`	`setOutpts.emplace(outpt);`
`211`	`209`	`}`
`212`	`210`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1390,10 +1390,8 @@ static RPCHelpMan protx_list()`
`1390`	`1390`	`throw JSONRPCError(RPC_INVALID_PARAMETER, "invalid height specified");`
`1391`	`1391`	`}`
`1392`	`1392`
`1393`		`- std::vector<COutPoint> vOutpts;`
`1394`		`- wallet->ListProTxCoins(vOutpts);`
`1395`	`1393`	`std::set<COutPoint> setOutpts;`
`1396`		`- for (const auto& outpt : vOutpts) {`
	`1394`	`+ for (const auto& outpt : wallet->ListProTxCoins()) {`
`1397`	`1395`	`setOutpts.emplace(outpt);`
`1398`	`1396`	`}`
`1399`	`1397`
Original file line number	Diff line number	Diff line change
`@@ -255,15 +255,13 @@ class WalletImpl : public Wallet`
`255`	`255`	`LOCK(m_wallet->cs_wallet);`
`256`	`256`	`return m_wallet->IsLockedCoin(output.hash, output.n);`
`257`	`257`	`}`
`258`		`- void listLockedCoins(std::vector<COutPoint>& outputs) override`
	`258`	`+ std::vector<COutPoint> listLockedCoins() override`
`259`	`259`	`{`
`260`		`- LOCK(m_wallet->cs_wallet);`
`261`		`- return m_wallet->ListLockedCoins(outputs);`
	`260`	`+ return WITH_LOCK(m_wallet->cs_wallet, return m_wallet->ListLockedCoins());`
`262`	`261`	`}`
`263`		`- void listProTxCoins(std::vector<COutPoint>& outputs) override`
	`262`	`+ std::vector<COutPoint> listProTxCoins() override`
`264`	`263`	`{`
`265`		`- LOCK(m_wallet->cs_wallet);`
`266`		`- return m_wallet->ListProTxCoins(outputs);`
	`264`	`+ return WITH_LOCK(m_wallet->cs_wallet, return m_wallet->ListProTxCoins());`
`267`	`265`	`}`
`268`	`266`	`CTransactionRef createTransaction(const std::vector<CRecipient>& recipients,`
`269`	`267`	`const CCoinControl& coin_control,`
Original file line number	Diff line number	Diff line change
`@@ -922,18 +922,16 @@ CWalletTx* CWallet::AddToWallet(CTransactionRef tx, const CWalletTx::Confirmatio`
`922`	`922`	`wtx.nTimeSmart = ComputeTimeSmart(wtx);`
`923`	`923`	`AddToSpends(hash, &batch);`
`924`	`924`
`925`		`- std::vector<std::pair<const CTransactionRef&, unsigned int>> outputs;`
`926`		`- for(unsigned int i = 0; i < wtx.tx->vout.size(); ++i) {`
	`925`	`+ std::set<COutPoint> candidates;`
	`926`	`+ for (unsigned int i = 0; i < wtx.tx->vout.size(); ++i) {`
`927`	`927`	`if (IsMine(wtx.tx->vout[i]) && !IsSpent(hash, i)) {`
`928`	`928`	`setWalletUTXO.insert(COutPoint(hash, i));`
`929`		`- outputs.emplace_back(wtx.tx, i);`
	`929`	`+ candidates.emplace(hash, i);`
`930`	`930`	`}`
`931`	`931`	`}`
`932`	`932`	`// TODO: refactor duplicated code between CWallet::AddToWallet and CWallet::AutoLockMasternodeCollaterals`
`933`		`- if (m_chain) {`
`934`		`- for (const auto& outPoint : m_chain->listMNCollaterials(outputs)) {`
`935`		`- LockCoin(outPoint, &batch);`
`936`		`- }`
	`933`	`+ for (const auto& utxo : ListProTxCoins(candidates)) {`
	`934`	`+ LockCoin(utxo, &batch);`
`937`	`935`	`}`
`938`	`936`	`}`
`939`	`937`
`@@ -951,21 +949,19 @@ CWalletTx* CWallet::AddToWallet(CTransactionRef tx, const CWalletTx::Confirmatio`
`951`	`949`	`assert(wtx.m_confirm.block_height == confirm.block_height);`
`952`	`950`	`}`
`953`	`951`
`954`		`- std::vector<std::pair<const CTransactionRef&, unsigned int>> outputs;`
`955`		`- for(unsigned int i = 0; i < wtx.tx->vout.size(); ++i) {`
	`952`	`+ std::set<COutPoint> candidates;`
	`953`	`+ for (unsigned int i = 0; i < wtx.tx->vout.size(); ++i) {`
`956`	`954`	`if (IsMine(wtx.tx->vout[i]) && !IsSpent(hash, i)) {`
`957`	`955`	`bool new_utxo = setWalletUTXO.insert(COutPoint(hash, i)).second;`
`958`	`956`	`if (new_utxo) {`
`959`		`- outputs.emplace_back(wtx.tx, i);`
	`957`	`+ candidates.emplace(hash, i);`
`960`	`958`	`fUpdated = true;`
`961`	`959`	`}`
`962`	`960`	`}`
`963`	`961`	`}`
`964`	`962`	`// TODO: refactor duplicated code with case fInstertedNew`
`965`		`- if (m_chain) {`
`966`		`- for (const auto& outPoint : m_chain->listMNCollaterials(outputs)) {`
`967`		`- LockCoin(outPoint);`
`968`		`- }`
	`963`	`+ for (const auto& utxo : ListProTxCoins(candidates)) {`
	`964`	`+ LockCoin(utxo, &batch);`
`969`	`965`	`}`
`970`	`966`	`}`
`971`	`967`
`@@ -2799,8 +2795,7 @@ std::map<CTxDestination, std::vector<COutput>> CWallet::ListCoins() const`
`2799`	`2795`	`}`
`2800`	`2796`	`}`
`2801`	`2797`
`2802`		`- std::vector<COutPoint> lockedCoins;`
`2803`		`- ListLockedCoins(lockedCoins);`
	`2798`	`+ std::vector<COutPoint> lockedCoins{ListLockedCoins()};`
`2804`	`2799`	`// Include watch-only for LegacyScriptPubKeyMan wallets without private keys`
`2805`	`2800`	`const bool include_watch_only = GetLegacyScriptPubKeyMan() && IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS);`
`2806`	`2801`	`const isminetype is_mine_filter = include_watch_only ? ISMINE_WATCH_ONLY : ISMINE_SPENDABLE;`
`@@ -4056,20 +4051,18 @@ DBErrors CWallet::LoadWallet()`
`4056`	`4051`	`// This avoids accidental spending of collaterals. They can still be unlocked manually if a spend is really intended.`
`4057`	`4052`	`void CWallet::AutoLockMasternodeCollaterals()`
`4058`	`4053`	`{`
`4059`		`- if (!m_chain) return;`
`4060`		`-`
`4061`		`- std::vector<std::pair<const CTransactionRef&, unsigned int>> outputs;`
`4062`		`-`
`4063`	`4054`	`LOCK(cs_wallet);`
`4064`		`- for (const auto& pair : mapWallet) {`
`4065`		`- for (unsigned int i = 0; i < pair.second.tx->vout.size(); ++i) {`
`4066`		`- if (IsMine(pair.second.tx->vout[i]) && !IsSpent(pair.first, i)) {`
`4067`		`- outputs.emplace_back(pair.second.tx, i);`
	`4055`	`+ std::set<COutPoint> candidates;`
	`4056`	`+ for (const auto& [txid, wtx] : mapWallet) {`
	`4057`	`+ for (unsigned int i = 0; i < wtx.tx->vout.size(); ++i) {`
	`4058`	`+ if (IsMine(wtx.tx->vout[i]) && !IsSpent(txid, i)) {`
	`4059`	`+ candidates.emplace(txid, i);`
`4068`	`4060`	`}`
`4069`	`4061`	`}`
`4070`	`4062`	`}`
`4071`		`- for (const auto& outPoint : m_chain->listMNCollaterials(outputs)) {`
`4072`		`- LockCoin(outPoint);`
	`4063`	`+ WalletBatch batch(GetDatabase());`
	`4064`	`+ for (const auto& utxo : ListProTxCoins(candidates)) {`
	`4065`	`+ LockCoin(utxo, &batch);`
`4073`	`4066`	`}`
`4074`	`4067`	`}`
`4075`	`4068`
`@@ -4502,34 +4495,32 @@ bool CWallet::IsLockedCoin(uint256 hash, unsigned int n) const`
`4502`	`4495`	`return (setLockedCoins.count(outpt) > 0);`
`4503`	`4496`	`}`
`4504`	`4497`
`4505`		`-void CWallet::ListLockedCoins(std::vector<COutPoint>& vOutpts) const`
	`4498`	`+std::vector<COutPoint> CWallet::ListLockedCoins() const`
`4506`	`4499`	`{`
`4507`	`4500`	`AssertLockHeld(cs_wallet);`
`4508`		`- for (std::set<COutPoint>::iterator it = setLockedCoins.begin();`
`4509`		`- it != setLockedCoins.end(); it++) {`
`4510`		`- COutPoint outpt = (*it);`
`4511`		`- vOutpts.push_back(outpt);`
	`4501`	`+ std::vector<COutPoint> ret;`
	`4502`	`+ for (const auto& output : setLockedCoins) {`
	`4503`	`+ ret.push_back(output);`
`4512`	`4504`	`}`
	`4505`	`+ return ret;`
`4513`	`4506`	`}`
`4514`	`4507`
`4515`		`-void CWallet::ListProTxCoins(std::vector<COutPoint>& vOutpts) const`
`4516`		`-{`
`4517`		`- // TODO: refactor duplicated code between CWallet::AutoLockMasternodeCollaterals and CWallet::ListProTxCoins`
`4518`		`- if (!m_chain) {`
`4519`		`- vOutpts.clear();`
`4520`		`- return;`
`4521`		`- }`
`4522`		`- std::vector<std::pair<const CTransactionRef&, unsigned int>> outputs;`
	`4508`	`+std::vector<COutPoint> CWallet::ListProTxCoins() const { return ListProTxCoins(setWalletUTXO); }`
`4523`	`4509`
	`4510`	`+std::vector<COutPoint> CWallet::ListProTxCoins(const std::set<COutPoint>& utxos) const`
	`4511`	`+{`
`4524`	`4512`	`AssertLockHeld(cs_wallet);`
`4525`		`- for (const auto &o : setWalletUTXO) {`
`4526`		`- auto it = mapWallet.find(o.hash);`
`4527`		`- if (it != mapWallet.end()) {`
`4528`		`- const auto &ptx = it->second;`
`4529`		`- outputs.emplace_back(ptx.tx, o.n);`
	`4513`	`+`
	`4514`	`+ if (!m_chain) return std::vector<COutPoint>();`
	`4515`	`+`
	`4516`	`+ std::vector<std::pair<const CTransactionRef&, unsigned int>> candidates;`
	`4517`	`+ for (const auto& output : utxos) {`
	`4518`	`+ if (auto it = mapWallet.find(output.hash); it != mapWallet.end()) {`
	`4519`	`+ const auto& [hash, wtx] = *it;`
	`4520`	`+ candidates.emplace_back(wtx.tx, output.n);`
`4530`	`4521`	`}`
`4531`	`4522`	`}`
`4532`		`- vOutpts = m_chain->listMNCollaterials(outputs);`
	`4523`	`+ return m_chain->listMNCollaterials(candidates);`
`4533`	`4524`	`}`
`4534`	`4525`
`4535`	`4526`	`/** @} */ // end of Actions`