wallet: refactor GetNewDestination, use BResult

furszy · furszy · commit 111ea3ab7114 · 2022-07-08T11:18:35.000-03:00
diff --git a/src/bench/wallet_loading.cpp b/src/bench/wallet_loading.cpp
@@ -47,12 +47,11 @@ static void BenchUnloadWallet(std::shared_ptr<CWallet>&& wallet)
 
 static void AddTx(CWallet& wallet)
 {
-    bilingual_str error;
-    CTxDestination dest;
-    wallet.GetNewDestination(OutputType::BECH32, "", dest, error);
+    const auto& dest = wallet.GetNewDestination(OutputType::BECH32, "");
+    assert(dest.HasRes());
 
     CMutableTransaction mtx;
-    mtx.vout.push_back({COIN, GetScriptForDestination(dest)});
+    mtx.vout.push_back({COIN, GetScriptForDestination(dest.GetObj())});
     mtx.vin.push_back(CTxIn());
 
     wallet.AddToWallet(MakeTransactionRef(mtx), TxStateInactive{});
diff --git a/src/interfaces/wallet.h b/src/interfaces/wallet.h
@@ -88,7 +88,7 @@ class Wallet
     virtual std::string getWalletName() = 0;
 
     // Get a new address.
-    virtual bool getNewDestination(const OutputType type, const std::string label, CTxDestination& dest) = 0;
+    virtual BResult<CTxDestination> getNewDestination(const OutputType type, const std::string label) = 0;
 
     //! Get public key.
     virtual bool getPubKey(const CScript& script, const CKeyID& address, CPubKey& pub_key) = 0;
diff --git a/src/qt/addresstablemodel.cpp b/src/qt/addresstablemodel.cpp
@@ -370,23 +370,21 @@ QString AddressTableModel::addRow(const QString &type, const QString &label, con
     else if(type == Receive)
     {
         // Generate a new address to associate with given label
-        CTxDestination dest;
-        if(!walletModel->wallet().getNewDestination(address_type, strLabel, dest))
-        {
+        auto op_dest = walletModel->wallet().getNewDestination(address_type, strLabel);
+        if (!op_dest) {
             WalletModel::UnlockContext ctx(walletModel->requestUnlock());
-            if(!ctx.isValid())
-            {
+            if (!ctx.isValid()) {
                 // Unlock wallet failed or was cancelled
                 editStatus = WALLET_UNLOCK_FAILURE;
                 return QString();
             }
-            if(!walletModel->wallet().getNewDestination(address_type, strLabel, dest))
-            {
+            op_dest = walletModel->wallet().getNewDestination(address_type, strLabel);
+            if (!op_dest) {
                 editStatus = KEY_GENERATION_FAILURE;
                 return QString();
             }
         }
-        strAddress = EncodeDestination(dest);
+        strAddress = EncodeDestination(op_dest.GetObj());
     }
     else
     {
diff --git a/src/test/util/wallet.cpp b/src/test/util/wallet.cpp
@@ -20,11 +20,10 @@ const std::string ADDRESS_BCRT1_UNSPENDABLE = "bcrt1qqqqqqqqqqqqqqqqqqqqqqqqqqqq
 std::string getnewaddress(CWallet& w)
 {
     constexpr auto output_type = OutputType::BECH32;
-    CTxDestination dest;
-    bilingual_str error;
-    if (!w.GetNewDestination(output_type, "", dest, error)) assert(false);
+    auto op_dest = w.GetNewDestination(output_type, "");
+    assert(op_dest.HasRes());
 
-    return EncodeDestination(dest);
+    return EncodeDestination(op_dest.GetObj());
 }
 
 #endif // ENABLE_WALLET
diff --git a/src/wallet/interfaces.cpp b/src/wallet/interfaces.cpp
@@ -146,11 +146,10 @@ class WalletImpl : public Wallet
     void abortRescan() override { m_wallet->AbortRescan(); }
     bool backupWallet(const std::string& filename) override { return m_wallet->BackupWallet(filename); }
     std::string getWalletName() override { return m_wallet->GetName(); }
-    bool getNewDestination(const OutputType type, const std::string label, CTxDestination& dest) override
+    BResult<CTxDestination> getNewDestination(const OutputType type, const std::string label) override
     {
         LOCK(m_wallet->cs_wallet);
-        bilingual_str error;
-        return m_wallet->GetNewDestination(type, label, dest, error);
+        return m_wallet->GetNewDestination(type, label);
     }
     bool getPubKey(const CScript& script, const CKeyID& address, CPubKey& pub_key) override
     {
diff --git a/src/wallet/rpc/addresses.cpp b/src/wallet/rpc/addresses.cpp
@@ -58,13 +58,12 @@ RPCHelpMan getnewaddress()
         output_type = parsed.value();
     }
 
-    CTxDestination dest;
-    bilingual_str error;
-    if (!pwallet->GetNewDestination(output_type, label, dest, error)) {
-        throw JSONRPCError(RPC_WALLET_KEYPOOL_RAN_OUT, error.original);
+    auto op_dest = pwallet->GetNewDestination(output_type, label);
+    if (!op_dest) {
+        throw JSONRPCError(RPC_WALLET_KEYPOOL_RAN_OUT, op_dest.GetError().original);
     }
 
-    return EncodeDestination(dest);
+    return EncodeDestination(op_dest.GetObj());
 },
     };
 }
@@ -106,12 +105,11 @@ RPCHelpMan getrawchangeaddress()
         output_type = parsed.value();
     }
 
-    CTxDestination dest;
-    bilingual_str error;
-    if (!pwallet->GetNewChangeDestination(output_type, dest, error)) {
-        throw JSONRPCError(RPC_WALLET_KEYPOOL_RAN_OUT, error.original);
+    auto op_dest = pwallet->GetNewChangeDestination(output_type);
+    if (!op_dest) {
+        throw JSONRPCError(RPC_WALLET_KEYPOOL_RAN_OUT, op_dest.GetError().original);
     }
-    return EncodeDestination(dest);
+    return EncodeDestination(op_dest.GetObj());
 },
     };
 }
diff --git a/src/wallet/scriptpubkeyman.cpp b/src/wallet/scriptpubkeyman.cpp
@@ -21,26 +21,22 @@ namespace wallet {
 //! Value for the first BIP 32 hardened derivation. Can be used as a bit mask and as a value. See BIP 32 for more details.
 const uint32_t BIP32_HARDENED_KEY_LIMIT = 0x80000000;
 
-bool LegacyScriptPubKeyMan::GetNewDestination(const OutputType type, CTxDestination& dest, bilingual_str& error)
+BResult<CTxDestination> LegacyScriptPubKeyMan::GetNewDestination(const OutputType type)
 {
     if (LEGACY_OUTPUT_TYPES.count(type) == 0) {
-        error = _("Error: Legacy wallets only support the \"legacy\", \"p2sh-segwit\", and \"bech32\" address types");
-        return false;
+        return _("Error: Legacy wallets only support the \"legacy\", \"p2sh-segwit\", and \"bech32\" address types");;
     }
     assert(type != OutputType::BECH32M);
 
     LOCK(cs_KeyStore);
-    error.clear();
 
     // Generate a new key that is added to wallet
     CPubKey new_key;
     if (!GetKeyFromPool(new_key, type)) {
-        error = _("Error: Keypool ran out, please call keypoolrefill first");
-        return false;
+        return _("Error: Keypool ran out, please call keypoolrefill first");
     }
     LearnRelatedScripts(new_key, type);
-    dest = GetDestinationForKey(new_key, type);
-    return true;
+    return GetDestinationForKey(new_key, type);
 }
 
 typedef std::vector<unsigned char> valtype;
@@ -1658,12 +1654,11 @@ std::set<CKeyID> LegacyScriptPubKeyMan::GetKeys() const
     return set_address;
 }
 
-bool DescriptorScriptPubKeyMan::GetNewDestination(const OutputType type, CTxDestination& dest, bilingual_str& error)
+BResult<CTxDestination> DescriptorScriptPubKeyMan::GetNewDestination(const OutputType type)
 {
     // Returns true if this descriptor supports getting new addresses. Conditions where we may be unable to fetch them (e.g. locked) are caught later
     if (!CanGetAddresses()) {
-        error = _("No addresses available");
-        return false;
+        return _("No addresses available");
     }
     {
         LOCK(cs_desc_man);
@@ -1681,15 +1676,14 @@ bool DescriptorScriptPubKeyMan::GetNewDestination(const OutputType type, CTxDest
         std::vector<CScript> scripts_temp;
         if (m_wallet_descriptor.range_end <= m_max_cached_index && !TopUp(1)) {
             // We can't generate anymore keys
-            error = _("Error: Keypool ran out, please call keypoolrefill first");
-            return false;
+            return _("Error: Keypool ran out, please call keypoolrefill first");
         }
         if (!m_wallet_descriptor.descriptor->ExpandFromCache(m_wallet_descriptor.next_index, m_wallet_descriptor.cache, scripts_temp, out_keys)) {
             // We can't generate anymore keys
-            error = _("Error: Keypool ran out, please call keypoolrefill first");
-            return false;
+            return _("Error: Keypool ran out, please call keypoolrefill first");
         }
 
+        CTxDestination dest;
         std::optional<OutputType> out_script_type = m_wallet_descriptor.descriptor->GetOutputType();
         if (out_script_type && out_script_type == type) {
             ExtractDestination(scripts_temp[0], dest);
@@ -1698,7 +1692,7 @@ bool DescriptorScriptPubKeyMan::GetNewDestination(const OutputType type, CTxDest
         }
         m_wallet_descriptor.next_index++;
         WalletBatch(m_storage.GetDatabase()).WriteDescriptor(GetID(), m_wallet_descriptor);
-        return true;
+        return dest;
     }
 }
 
@@ -1769,9 +1763,14 @@ bool DescriptorScriptPubKeyMan::Encrypt(const CKeyingMaterial& master_key, Walle
 bool DescriptorScriptPubKeyMan::GetReservedDestination(const OutputType type, bool internal, CTxDestination& address, int64_t& index, CKeyPool& keypool, bilingual_str& error)
 {
     LOCK(cs_desc_man);
-    bool result = GetNewDestination(type, address, error);
+    auto op_dest = GetNewDestination(type);
     index = m_wallet_descriptor.next_index - 1;
-    return result;
+    if (op_dest) {
+        address = op_dest.GetObj();
+    } else {
+        error = op_dest.GetError();
+    }
+    return op_dest.HasRes();
 }
 
 void DescriptorScriptPubKeyMan::ReturnDestination(int64_t index, bool internal, const CTxDestination& addr)
diff --git a/src/wallet/scriptpubkeyman.h b/src/wallet/scriptpubkeyman.h
@@ -11,6 +11,7 @@
 #include <script/standard.h>
 #include <util/error.h>
 #include <util/message.h>
+#include <util/result.h>
 #include <util/time.h>
 #include <wallet/crypter.h>
 #include <wallet/ismine.h>
@@ -171,7 +172,7 @@ class ScriptPubKeyMan
 public:
     explicit ScriptPubKeyMan(WalletStorage& storage) : m_storage(storage) {}
     virtual ~ScriptPubKeyMan() {};
-    virtual bool GetNewDestination(const OutputType type, CTxDestination& dest, bilingual_str& error) { return false; }
+    virtual BResult<CTxDestination> GetNewDestination(const OutputType type) { return Untranslated("Not supported"); }
     virtual isminetype IsMine(const CScript& script) const { return ISMINE_NO; }
 
     //! Check that the given decryption key is valid for this ScriptPubKeyMan, i.e. it decrypts all of the keys handled by it.
@@ -359,7 +360,7 @@ class LegacyScriptPubKeyMan : public ScriptPubKeyMan, public FillableSigningProv
 public:
     using ScriptPubKeyMan::ScriptPubKeyMan;
 
-    bool GetNewDestination(const OutputType type, CTxDestination& dest, bilingual_str& error) override;
+    BResult<CTxDestination> GetNewDestination(const OutputType type) override;
     isminetype IsMine(const CScript& script) const override;
 
     bool CheckDecryptionKey(const CKeyingMaterial& master_key, bool accept_no_keys = false) override;
@@ -567,7 +568,7 @@ class DescriptorScriptPubKeyMan : public ScriptPubKeyMan
 
     mutable RecursiveMutex cs_desc_man;
 
-    bool GetNewDestination(const OutputType type, CTxDestination& dest, bilingual_str& error) override;
+    BResult<CTxDestination> GetNewDestination(const OutputType type) override;
     isminetype IsMine(const CScript& script) const override;
 
     bool CheckDecryptionKey(const CKeyingMaterial& master_key, bool accept_no_keys = false) override;
diff --git a/src/wallet/test/coinselector_tests.cpp b/src/wallet/test/coinselector_tests.cpp
@@ -74,11 +74,9 @@ static void add_coin(std::vector<COutput>& coins, CWallet& wallet, const CAmount
     tx.vout.resize(nInput + 1);
     tx.vout[nInput].nValue = nValue;
     if (spendable) {
-        CTxDestination dest;
-        bilingual_str error;
-        const bool destination_ok = wallet.GetNewDestination(OutputType::BECH32, "", dest, error);
-        assert(destination_ok);
-        tx.vout[nInput].scriptPubKey = GetScriptForDestination(dest);
+        auto op_dest = wallet.GetNewDestination(OutputType::BECH32, "");
+        assert(op_dest.HasRes());
+        tx.vout[nInput].scriptPubKey = GetScriptForDestination(op_dest.GetObj());
     }
     uint256 txid = tx.GetHash();
 
diff --git a/src/wallet/test/fuzz/notifications.cpp b/src/wallet/test/fuzz/notifications.cpp
@@ -69,15 +69,14 @@ struct FuzzedWallet {
     CScript GetScriptPubKey(FuzzedDataProvider& fuzzed_data_provider)
     {
         auto type{fuzzed_data_provider.PickValueInArray(OUTPUT_TYPES)};
-        CTxDestination dest;
-        bilingual_str error;
+        BResult<CTxDestination> op_dest;
         if (fuzzed_data_provider.ConsumeBool()) {
-            assert(wallet->GetNewDestination(type, "", dest, error));
+            op_dest = wallet->GetNewDestination(type, "");
         } else {
-            assert(wallet->GetNewChangeDestination(type, dest, error));
+            op_dest = wallet->GetNewChangeDestination(type);
         }
-        assert(error.empty());
-        return GetScriptForDestination(dest);
+        assert(op_dest.HasRes());
+        return GetScriptForDestination(op_dest.GetObj());
     }
 };
 
diff --git a/src/wallet/test/wallet_tests.cpp b/src/wallet/test/wallet_tests.cpp
@@ -610,19 +610,15 @@ BOOST_FIXTURE_TEST_CASE(wallet_disableprivkeys, TestChain100Setup)
         wallet->SetMinVersion(FEATURE_LATEST);
         wallet->SetWalletFlag(WALLET_FLAG_DISABLE_PRIVATE_KEYS);
         BOOST_CHECK(!wallet->TopUpKeyPool(1000));
-        CTxDestination dest;
-        bilingual_str error;
-        BOOST_CHECK(!wallet->GetNewDestination(OutputType::BECH32, "", dest, error));
+        BOOST_CHECK(!wallet->GetNewDestination(OutputType::BECH32, ""));
     }
     {
         const std::shared_ptr<CWallet> wallet = std::make_shared<CWallet>(m_node.chain.get(), "", m_args, CreateDummyWalletDatabase());
         LOCK(wallet->cs_wallet);
         wallet->SetWalletFlag(WALLET_FLAG_DESCRIPTORS);
         wallet->SetMinVersion(FEATURE_LATEST);
         wallet->SetWalletFlag(WALLET_FLAG_DISABLE_PRIVATE_KEYS);
-        CTxDestination dest;
-        bilingual_str error;
-        BOOST_CHECK(!wallet->GetNewDestination(OutputType::BECH32, "", dest, error));
+        BOOST_CHECK(!wallet->GetNewDestination(OutputType::BECH32, ""));
     }
 }
 
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
@@ -2307,37 +2307,36 @@ bool CWallet::TopUpKeyPool(unsigned int kpSize)
     return res;
 }
 
-bool CWallet::GetNewDestination(const OutputType type, const std::string label, CTxDestination& dest, bilingual_str& error)
+BResult<CTxDestination> CWallet::GetNewDestination(const OutputType type, const std::string label)
 {
     LOCK(cs_wallet);
-    error.clear();
-    bool result = false;
     auto spk_man = GetScriptPubKeyMan(type, false /* internal */);
-    if (spk_man) {
-        spk_man->TopUp();
-        result = spk_man->GetNewDestination(type, dest, error);
-    } else {
-        error = strprintf(_("Error: No %s addresses available."), FormatOutputType(type));
+    if (!spk_man) {
+        return strprintf(_("Error: No %s addresses available."), FormatOutputType(type));
     }
-    if (result) {
-        SetAddressBook(dest, label, "receive");
+
+    spk_man->TopUp();
+    auto op_dest = spk_man->GetNewDestination(type);
+    if (op_dest) {
+        SetAddressBook(op_dest.GetObj(), label, "receive");
     }
 
-    return result;
+    return op_dest;
 }
 
-bool CWallet::GetNewChangeDestination(const OutputType type, CTxDestination& dest, bilingual_str& error)
+BResult<CTxDestination> CWallet::GetNewChangeDestination(const OutputType type)
 {
     LOCK(cs_wallet);
-    error.clear();
 
+    CTxDestination dest;
+    bilingual_str error;
     ReserveDestination reservedest(this, type);
     if (!reservedest.GetReservedDestination(dest, true, error)) {
-        return false;
+        return error;
     }
 
     reservedest.KeepDestination();
-    return true;
+    return dest;
 }
 
 std::optional<int64_t> CWallet::GetOldestKeyPoolTime() const
diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h
@@ -15,6 +15,7 @@
 #include <psbt.h>
 #include <tinyformat.h>
 #include <util/message.h>
+#include <util/result.h>
 #include <util/strencodings.h>
 #include <util/string.h>
 #include <util/system.h>
@@ -665,8 +666,8 @@ class CWallet final : public WalletStorage, public interfaces::Chain::Notificati
      */
     void MarkDestinationsDirty(const std::set<CTxDestination>& destinations) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
-    bool GetNewDestination(const OutputType type, const std::string label, CTxDestination& dest, bilingual_str& error);
-    bool GetNewChangeDestination(const OutputType type, CTxDestination& dest, bilingual_str& error);
+    BResult<CTxDestination> GetNewDestination(const OutputType type, const std::string label);
+    BResult<CTxDestination> GetNewChangeDestination(const OutputType type);
 
     isminetype IsMine(const CTxDestination& dest) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
     isminetype IsMine(const CScript& script) const EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);

Original file line number	Diff line number	Diff line change
`@@ -370,23 +370,21 @@ QString AddressTableModel::addRow(const QString &type, const QString &label, con`
`370`	`370`	`else if(type == Receive)`
`371`	`371`	`{`
`372`	`372`	`// Generate a new address to associate with given label`
`373`		`- CTxDestination dest;`
`374`		`- if(!walletModel->wallet().getNewDestination(address_type, strLabel, dest))`
`375`		`- {`
	`373`	`+ auto op_dest = walletModel->wallet().getNewDestination(address_type, strLabel);`
	`374`	`+ if (!op_dest) {`
`376`	`375`	`WalletModel::UnlockContext ctx(walletModel->requestUnlock());`
`377`		`- if(!ctx.isValid())`
`378`		`- {`
	`376`	`+ if (!ctx.isValid()) {`
`379`	`377`	`// Unlock wallet failed or was cancelled`
`380`	`378`	`editStatus = WALLET_UNLOCK_FAILURE;`
`381`	`379`	`return QString();`
`382`	`380`	`}`
`383`		`- if(!walletModel->wallet().getNewDestination(address_type, strLabel, dest))`
`384`		`- {`
	`381`	`+ op_dest = walletModel->wallet().getNewDestination(address_type, strLabel);`
	`382`	`+ if (!op_dest) {`
`385`	`383`	`editStatus = KEY_GENERATION_FAILURE;`
`386`	`384`	`return QString();`
`387`	`385`	`}`
`388`	`386`	`}`
`389`		`- strAddress = EncodeDestination(dest);`
	`387`	`+ strAddress = EncodeDestination(op_dest.GetObj());`
`390`	`388`	`}`
`391`	`389`	`else`
`392`	`390`	`{`
Original file line number	Diff line number	Diff line change
`@@ -20,11 +20,10 @@ const std::string ADDRESS_BCRT1_UNSPENDABLE = "bcrt1qqqqqqqqqqqqqqqqqqqqqqqqqqqq`
`20`	`20`	`std::string getnewaddress(CWallet& w)`
`21`	`21`	`{`
`22`	`22`	`constexpr auto output_type = OutputType::BECH32;`
`23`		`- CTxDestination dest;`
`24`		`- bilingual_str error;`
`25`		`- if (!w.GetNewDestination(output_type, "", dest, error)) assert(false);`
	`23`	`+ auto op_dest = w.GetNewDestination(output_type, "");`
	`24`	`+ assert(op_dest.HasRes());`
`26`	`25`
`27`		`- return EncodeDestination(dest);`
	`26`	`+ return EncodeDestination(op_dest.GetObj());`
`28`	`27`	`}`
`29`	`28`
`30`	`29`	`#endif // ENABLE_WALLET`
Original file line number	Diff line number	Diff line change
`@@ -146,11 +146,10 @@ class WalletImpl : public Wallet`
`146`	`146`	`void abortRescan() override { m_wallet->AbortRescan(); }`
`147`	`147`	`bool backupWallet(const std::string& filename) override { return m_wallet->BackupWallet(filename); }`
`148`	`148`	`std::string getWalletName() override { return m_wallet->GetName(); }`
`149`		`- bool getNewDestination(const OutputType type, const std::string label, CTxDestination& dest) override`
	`149`	`+ BResult<CTxDestination> getNewDestination(const OutputType type, const std::string label) override`
`150`	`150`	`{`
`151`	`151`	`LOCK(m_wallet->cs_wallet);`
`152`		`- bilingual_str error;`
`153`		`- return m_wallet->GetNewDestination(type, label, dest, error);`
	`152`	`+ return m_wallet->GetNewDestination(type, label);`
`154`	`153`	`}`
`155`	`154`	`bool getPubKey(const CScript& script, const CKeyID& address, CPubKey& pub_key) override`
`156`	`155`	`{`
Original file line number	Diff line number	Diff line change
`@@ -58,13 +58,12 @@ RPCHelpMan getnewaddress()`
`58`	`58`	`output_type = parsed.value();`
`59`	`59`	`}`
`60`	`60`
`61`		`- CTxDestination dest;`
`62`		`- bilingual_str error;`
`63`		`- if (!pwallet->GetNewDestination(output_type, label, dest, error)) {`
`64`		`- throw JSONRPCError(RPC_WALLET_KEYPOOL_RAN_OUT, error.original);`
	`61`	`+ auto op_dest = pwallet->GetNewDestination(output_type, label);`
	`62`	`+ if (!op_dest) {`
	`63`	`+ throw JSONRPCError(RPC_WALLET_KEYPOOL_RAN_OUT, op_dest.GetError().original);`
`65`	`64`	`}`
`66`	`65`
`67`		`- return EncodeDestination(dest);`
	`66`	`+ return EncodeDestination(op_dest.GetObj());`
`68`	`67`	`},`
`69`	`68`	`};`
`70`	`69`	`}`
`@@ -106,12 +105,11 @@ RPCHelpMan getrawchangeaddress()`
`106`	`105`	`output_type = parsed.value();`
`107`	`106`	`}`
`108`	`107`
`109`		`- CTxDestination dest;`
`110`		`- bilingual_str error;`
`111`		`- if (!pwallet->GetNewChangeDestination(output_type, dest, error)) {`
`112`		`- throw JSONRPCError(RPC_WALLET_KEYPOOL_RAN_OUT, error.original);`
	`108`	`+ auto op_dest = pwallet->GetNewChangeDestination(output_type);`
	`109`	`+ if (!op_dest) {`
	`110`	`+ throw JSONRPCError(RPC_WALLET_KEYPOOL_RAN_OUT, op_dest.GetError().original);`
`113`	`111`	`}`
`114`		`- return EncodeDestination(dest);`
	`112`	`+ return EncodeDestination(op_dest.GetObj());`
`115`	`113`	`},`
`116`	`114`	`};`
`117`	`115`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,26 +21,22 @@ namespace wallet {`
`21`	`21`	`//! Value for the first BIP 32 hardened derivation. Can be used as a bit mask and as a value. See BIP 32 for more details.`
`22`	`22`	`const uint32_t BIP32_HARDENED_KEY_LIMIT = 0x80000000;`
`23`	`23`
`24`		`-bool LegacyScriptPubKeyMan::GetNewDestination(const OutputType type, CTxDestination& dest, bilingual_str& error)`
	`24`	`+BResult<CTxDestination> LegacyScriptPubKeyMan::GetNewDestination(const OutputType type)`
`25`	`25`	`{`
`26`	`26`	`if (LEGACY_OUTPUT_TYPES.count(type) == 0) {`
`27`		`- error = _("Error: Legacy wallets only support the \"legacy\", \"p2sh-segwit\", and \"bech32\" address types");`
`28`		`- return false;`
	`27`	`+ return _("Error: Legacy wallets only support the \"legacy\", \"p2sh-segwit\", and \"bech32\" address types");;`
`29`	`28`	`}`
`30`	`29`	`assert(type != OutputType::BECH32M);`
`31`	`30`
`32`	`31`	`LOCK(cs_KeyStore);`
`33`		`- error.clear();`
`34`	`32`
`35`	`33`	`// Generate a new key that is added to wallet`
`36`	`34`	`CPubKey new_key;`
`37`	`35`	`if (!GetKeyFromPool(new_key, type)) {`
`38`		`- error = _("Error: Keypool ran out, please call keypoolrefill first");`
`39`		`- return false;`
	`36`	`+ return _("Error: Keypool ran out, please call keypoolrefill first");`
`40`	`37`	`}`
`41`	`38`	`LearnRelatedScripts(new_key, type);`
`42`		`- dest = GetDestinationForKey(new_key, type);`
`43`		`- return true;`
	`39`	`+ return GetDestinationForKey(new_key, type);`
`44`	`40`	`}`
`45`	`41`
`46`	`42`	`typedef std::vector<unsigned char> valtype;`
`@@ -1658,12 +1654,11 @@ std::set<CKeyID> LegacyScriptPubKeyMan::GetKeys() const`
`1658`	`1654`	`return set_address;`
`1659`	`1655`	`}`
`1660`	`1656`
`1661`		`-bool DescriptorScriptPubKeyMan::GetNewDestination(const OutputType type, CTxDestination& dest, bilingual_str& error)`
	`1657`	`+BResult<CTxDestination> DescriptorScriptPubKeyMan::GetNewDestination(const OutputType type)`
`1662`	`1658`	`{`
`1663`	`1659`	`// Returns true if this descriptor supports getting new addresses. Conditions where we may be unable to fetch them (e.g. locked) are caught later`
`1664`	`1660`	`if (!CanGetAddresses()) {`
`1665`		`- error = _("No addresses available");`
`1666`		`- return false;`
	`1661`	`+ return _("No addresses available");`
`1667`	`1662`	`}`
`1668`	`1663`	`{`
`1669`	`1664`	`LOCK(cs_desc_man);`
`@@ -1681,15 +1676,14 @@ bool DescriptorScriptPubKeyMan::GetNewDestination(const OutputType type, CTxDest`
`1681`	`1676`	`std::vector<CScript> scripts_temp;`
`1682`	`1677`	`if (m_wallet_descriptor.range_end <= m_max_cached_index && !TopUp(1)) {`
`1683`	`1678`	`// We can't generate anymore keys`
`1684`		`- error = _("Error: Keypool ran out, please call keypoolrefill first");`
`1685`		`- return false;`
	`1679`	`+ return _("Error: Keypool ran out, please call keypoolrefill first");`
`1686`	`1680`	`}`
`1687`	`1681`	`if (!m_wallet_descriptor.descriptor->ExpandFromCache(m_wallet_descriptor.next_index, m_wallet_descriptor.cache, scripts_temp, out_keys)) {`
`1688`	`1682`	`// We can't generate anymore keys`
`1689`		`- error = _("Error: Keypool ran out, please call keypoolrefill first");`
`1690`		`- return false;`
	`1683`	`+ return _("Error: Keypool ran out, please call keypoolrefill first");`
`1691`	`1684`	`}`
`1692`	`1685`
	`1686`	`+ CTxDestination dest;`
`1693`	`1687`	`std::optional<OutputType> out_script_type = m_wallet_descriptor.descriptor->GetOutputType();`
`1694`	`1688`	`if (out_script_type && out_script_type == type) {`
`1695`	`1689`	`ExtractDestination(scripts_temp[0], dest);`
`@@ -1698,7 +1692,7 @@ bool DescriptorScriptPubKeyMan::GetNewDestination(const OutputType type, CTxDest`
`1698`	`1692`	`}`
`1699`	`1693`	`m_wallet_descriptor.next_index++;`
`1700`	`1694`	`WalletBatch(m_storage.GetDatabase()).WriteDescriptor(GetID(), m_wallet_descriptor);`
`1701`		`- return true;`
	`1695`	`+ return dest;`
`1702`	`1696`	`}`
`1703`	`1697`	`}`
`1704`	`1698`
`@@ -1769,9 +1763,14 @@ bool DescriptorScriptPubKeyMan::Encrypt(const CKeyingMaterial& master_key, Walle`
`1769`	`1763`	`bool DescriptorScriptPubKeyMan::GetReservedDestination(const OutputType type, bool internal, CTxDestination& address, int64_t& index, CKeyPool& keypool, bilingual_str& error)`
`1770`	`1764`	`{`
`1771`	`1765`	`LOCK(cs_desc_man);`
`1772`		`- bool result = GetNewDestination(type, address, error);`
	`1766`	`+ auto op_dest = GetNewDestination(type);`
`1773`	`1767`	`index = m_wallet_descriptor.next_index - 1;`
`1774`		`- return result;`
	`1768`	`+ if (op_dest) {`
	`1769`	`+ address = op_dest.GetObj();`
	`1770`	`+ } else {`
	`1771`	`+ error = op_dest.GetError();`
	`1772`	`+ }`
	`1773`	`+ return op_dest.HasRes();`
`1775`	`1774`	`}`
`1776`	`1775`
`1777`	`1776`	`void DescriptorScriptPubKeyMan::ReturnDestination(int64_t index, bool internal, const CTxDestination& addr)`