From f1903eb647359947652e801844a5ba8e9e73e2c7 Mon Sep 17 00:00:00 2001
From: pasta <pasta@dashboost.org>
Date: Sat, 15 Aug 2026 15:33:07 -0500
Subject: [PATCH 1/6] feat(evo): expose whether an operator key is in use at
 the chain tip

Add an interfaces::EVO query predicate answering whether an operator BLS
public key is assigned to any masternode in the deterministic list at the
current chain tip, probing both BLS scheme encodings. This is a per-key
chainstate query for callers that select fresh operator keys; it is a UX
guard rather than a safety mechanism, so an unready node answers false.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
---
 src/interfaces/node.h                   | 10 +++++++
 src/node/interfaces.cpp                 | 19 +++++++++++++
 src/test/evo_deterministicmns_tests.cpp | 38 +++++++++++++++++++++++++
 3 files changed, 67 insertions(+)

diff --git a/src/interfaces/node.h b/src/interfaces/node.h
index f3362cefba6b..59a3be12e44a 100644
--- a/src/interfaces/node.h
+++ b/src/interfaces/node.h
@@ -30,6 +30,7 @@
 
 class BanMan;
 class CBlockIndex;
+class CBLSPublicKey;
 class CDeterministicMNList;
 class CFeeRate;
 class CGovernanceObject;
@@ -151,6 +152,15 @@ class EVO
         Wallet& wallet, const ProviderUpdateRegistrarRequest& request) = 0;
     virtual ProviderTxResult<ProviderTxSubmission> revokeMasternode(Wallet& wallet,
                                                                     const ProviderRevokeRequest& request) = 0;
+    /**
+     * Whether an operator public key is assigned to any masternode in the
+     * deterministic list at the current chain tip, under either BLS scheme
+     * encoding. This is a UX guard for skipping keys that would be rejected
+     * by DIP3 duplicate-key checks, not a safety mechanism: when the node is
+     * not ready to answer (no tip or no masternode manager yet), it returns
+     * false. Keys used only historically also return false.
+     */
+    virtual bool isMasternodeOperatorKeyInUse(const CBLSPublicKey& public_key) = 0;
     virtual void setContext(node::NodeContext* context) {}
 };
 
diff --git a/src/node/interfaces.cpp b/src/node/interfaces.cpp
index c57159887945..9bb5cf644a8a 100644
--- a/src/node/interfaces.cpp
+++ b/src/node/interfaces.cpp
@@ -270,6 +270,25 @@ class EVOImpl : public EVO
     {
         return evo::provider::Revoke(context(), wallet, request);
     }
+    bool isMasternodeOperatorKeyInUse(const CBLSPublicKey& public_key) override
+    {
+        if (!m_context || !m_context->chainman || !m_context->dmnman) return false;
+        const CBlockIndex* tip{WITH_LOCK(::cs_main, return chainman().ActiveChain().Tip())};
+        if (!tip) return false;
+        CDeterministicMNList mn_list;
+        try {
+            mn_list = m_context->dmnman->GetListForBlock(tip);
+        } catch (const BlockDataUnavailableError& e) {
+            // Expected while a snapshot's background chainstate is still
+            // catching up; this predicate fails open by design. Any other
+            // exception means local EvoDB/list corruption and must not be
+            // hidden, so it deliberately stays unhandled.
+            LogPrintf("%s -- masternode list unavailable: %s\n", __func__, e.what());
+            return false;
+        }
+        if (mn_list.GetBlockHash().IsNull()) return false;
+        return mn_list.HasOperatorKeyUnderAnyScheme(public_key, /*self=*/uint256());
+    }
     void setContext(NodeContext* context) override
     {
         m_context = context;
diff --git a/src/test/evo_deterministicmns_tests.cpp b/src/test/evo_deterministicmns_tests.cpp
index 8ca40a2d2909..0875847c35a0 100644
--- a/src/test/evo_deterministicmns_tests.cpp
+++ b/src/test/evo_deterministicmns_tests.cpp
@@ -16,6 +16,7 @@
 #include <evo/simplifiedmns.h>
 #include <evo/specialtx.h>
 #include <evo/specialtxman.h>
+#include <interfaces/node.h>
 #include <llmq/context.h>
 #include <node/mempool_args.h>
 #include <messagesigner.h>
@@ -1720,6 +1721,43 @@ BOOST_AUTO_TEST_CASE(v19_activation_legacy)
     FuncV19Activation(setup);
 }
 
+BOOST_AUTO_TEST_CASE(operator_key_in_use_follows_current_list)
+{
+    TestMNChainSetup setup(DIP3_ACTIVATION_HEIGHT - 2, {"-dip3params=109:500"});
+    setup.ProcessBlock(); // The next block may contain DIP3 transactions.
+
+    auto node{interfaces::MakeNode(setup.m_node)};
+    auto in_use = [&](const CBLSSecretKey& key) { return node->evo().isMasternodeOperatorKeyInUse(key.GetPublicKey()); };
+
+    BOOST_CHECK(!node->evo().isMasternodeOperatorKeyInUse(CBLSPublicKey{}));
+
+    CKey owner_key;
+    CBLSSecretKey registered_key;
+    auto tx_reg{CreateProRegTx(setup.chainman, setup.utxos, 19999, GenerateRandomAddress(), setup.coinbaseKey,
+                               owner_key, registered_key)};
+    BOOST_CHECK(!in_use(registered_key));
+    setup.ProcessBlock({tx_reg});
+    BOOST_CHECK(in_use(registered_key));
+
+    // Rotating the operator key makes the old key immediately reusable: the
+    // predicate answers for the current list, not for historical assignments.
+    CBLSSecretKey rotated_key;
+    rotated_key.MakeNewKey();
+    auto tx_upreg{CreateProUpRegTx(setup.chainman, setup.utxos, tx_reg.GetHash(), owner_key,
+                                   rotated_key.GetPublicKey(), owner_key.GetPubKey().GetID(), GenerateRandomAddress(),
+                                   setup.coinbaseKey)};
+    setup.ProcessBlock({tx_upreg});
+    BOOST_CHECK(!in_use(registered_key));
+    BOOST_CHECK(in_use(rotated_key));
+
+    // Revocation clears the operator key in the list while the masternode entry remains.
+    auto tx_revoke{CreateProUpRevTx(setup.chainman, setup.utxos, tx_reg.GetHash(), rotated_key, setup.coinbaseKey)};
+    setup.ProcessBlock({tx_revoke});
+    BOOST_REQUIRE(setup.dmnman.GetListAtChainTip().HasMN(tx_reg.GetHash()));
+    BOOST_CHECK(!in_use(registered_key));
+    BOOST_CHECK(!in_use(rotated_key));
+}
+
 // The invariant this whole change rests on: a stored operator key never advertises a scheme its own
 // state version contradicts, so the live list and the same list reloaded from disk agree — including
 // mnUniquePropertyMap, which IsEqual() compares directly.

From 198a9e2eb9325bf4e4c5eaab9cab58393d6d75b0 Mon Sep 17 00:00:00 2001
From: pasta <pasta@dashboost.org>
Date: Tue, 18 Aug 2026 11:09:37 -0500
Subject: [PATCH 2/6] feat(wallet): derive masternode operator keys from seed

Descriptor wallets backed by a single mnemonic can derive DashSync-compatible operator BLS keys at m/9'/coin'/3'/3'/index. Consumption is lowest-index-first and permanent, tracked by a watermark persisted before any secret is exposed. Issuance scans candidates against the current masternode list gap-limit style and a persisted lookahead of derived public keys lets sync/rescan advance the watermark opportunistically without the seed. Reuse protection is best-effort by design: it avoids accidental reuse without guaranteeing historical uniqueness, which the network's current-list uniqueness rules make harmless.

Legacy wallets are intentionally unsupported: legacy is deprecated and DashPay is descriptor-only, so a new feature should not entrench it. They keep bls generate plus a separate key backup.
---
 doc/release-notes-7594.md                     |   8 +
 src/Makefile.am                               |   2 +
 src/Makefile.test.include                     |   1 +
 src/bls/bls.h                                 |   7 +
 src/interfaces/masternode_operator.h          |  43 ++
 src/interfaces/wallet.h                       |  18 +
 src/wallet/interfaces.cpp                     |  18 +
 src/wallet/masternode_operator.h              |  90 +++
 src/wallet/rpc/wallet.cpp                     |  17 +
 src/wallet/salvage.cpp                        |   2 +-
 src/wallet/scriptpubkeyman.cpp                |  97 +++
 src/wallet/scriptpubkeyman.h                  |  31 +
 src/wallet/test/masternode_operator_tests.cpp | 634 ++++++++++++++++++
 src/wallet/wallet.cpp                         | 376 +++++++++++
 src/wallet/wallet.h                           |  56 ++
 src/wallet/walletdb.cpp                       |  45 ++
 src/wallet/walletdb.h                         |  11 +
 test/util/data/non-backported.txt             |   3 +
 18 files changed, 1458 insertions(+), 1 deletion(-)
 create mode 100644 doc/release-notes-7594.md
 create mode 100644 src/interfaces/masternode_operator.h
 create mode 100644 src/wallet/masternode_operator.h
 create mode 100644 src/wallet/test/masternode_operator_tests.cpp

diff --git a/doc/release-notes-7594.md b/doc/release-notes-7594.md
new file mode 100644
index 000000000000..c830898ea4b0
--- /dev/null
+++ b/doc/release-notes-7594.md
@@ -0,0 +1,8 @@
+Wallet
+------
+
+- Mnemonic-backed descriptor wallets can now derive DashSync-compatible
+  masternode operator BLS keys from the wallet seed, so the recovery phrase
+  also backs up operator keys. Restored wallets avoid keys that are currently
+  registered, but may reuse a key that was retired in the past. Other wallet
+  types remain unchanged and can continue using `bls generate`. (#7594)
diff --git a/src/Makefile.am b/src/Makefile.am
index 0cf8ce802fdb..132e6c7e34b5 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -281,6 +281,7 @@ BITCOIN_CORE_H = \
   interfaces/handler.h \
   interfaces/init.h \
   interfaces/ipc.h \
+  interfaces/masternode_operator.h \
   interfaces/node.h \
   interfaces/providertx.h \
   interfaces/wallet.h \
@@ -478,6 +479,7 @@ BITCOIN_CORE_H = \
   wallet/hdchain.h \
   wallet/ismine.h \
   wallet/load.h \
+  wallet/masternode_operator.h \
   wallet/receive.h \
   wallet/rpc/util.h \
   wallet/rpc/wallet.h \
diff --git a/src/Makefile.test.include b/src/Makefile.test.include
index 805083ffeb5f..2b4be209884c 100644
--- a/src/Makefile.test.include
+++ b/src/Makefile.test.include
@@ -224,6 +224,7 @@ if ENABLE_WALLET
 BITCOIN_TESTS += \
   wallet/test/bip39_tests.cpp \
   wallet/test/coinjoin_tests.cpp \
+  wallet/test/masternode_operator_tests.cpp \
   wallet/test/psbt_wallet_tests.cpp \
   wallet/test/spend_tests.cpp \
   wallet/test/wallet_tests.cpp \
diff --git a/src/bls/bls.h b/src/bls/bls.h
index ae2124cd38e1..f08f448a914e 100644
--- a/src/bls/bls.h
+++ b/src/bls/bls.h
@@ -283,6 +283,13 @@ class CBLSSecretKey : public CBLSWrapper<bls::PrivateKey, BLS_CURVE_SECKEY_SIZE,
     CBLSSecretKey(const CBLSSecretKey&) = default;
     CBLSSecretKey& operator=(const CBLSSecretKey&) = default;
 
+    bool SerializeTo(Span<unsigned char> bytes) const
+    {
+        if (!IsValid() || bytes.size() != SerSize) return false;
+        impl.Serialize(bytes.data());
+        return true;
+    }
+
     void AggregateInsecure(const CBLSSecretKey& o);
     static CBLSSecretKey AggregateInsecure(Span<CBLSSecretKey> sks);
 
diff --git a/src/interfaces/masternode_operator.h b/src/interfaces/masternode_operator.h
new file mode 100644
index 000000000000..6bbfeadb285a
--- /dev/null
+++ b/src/interfaces/masternode_operator.h
@@ -0,0 +1,43 @@
+// Copyright (c) 2026 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_INTERFACES_MASTERNODE_OPERATOR_H
+#define BITCOIN_INTERFACES_MASTERNODE_OPERATOR_H
+
+#include <support/allocators/secure.h>
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace interfaces {
+
+//! Result of a deterministic masternode operator-key operation.
+enum class MasternodeOperatorKeyStatus : uint8_t {
+    SUCCESS,
+    NOT_SUPPORTED,
+    WALLET_LOCKED,
+    EXHAUSTED,
+    INVALID_KEY,
+    NOT_FOUND,
+    DATABASE_ERROR,
+    DERIVATION_ERROR,
+};
+
+//! A deterministic masternode operator key returned by the wallet. The public
+//! key uses the canonical basic-scheme serialization.
+struct MasternodeOperatorKey {
+    SecureVector secret_key;
+    std::vector<unsigned char> public_key;
+    std::string path;
+};
+
+struct MasternodeOperatorKeyResult {
+    MasternodeOperatorKeyStatus status{MasternodeOperatorKeyStatus::DERIVATION_ERROR};
+    MasternodeOperatorKey key;
+};
+
+} // namespace interfaces
+
+#endif // BITCOIN_INTERFACES_MASTERNODE_OPERATOR_H
diff --git a/src/interfaces/wallet.h b/src/interfaces/wallet.h
index 9fc779906135..a78a20e4ff99 100644
--- a/src/interfaces/wallet.h
+++ b/src/interfaces/wallet.h
@@ -8,6 +8,7 @@
 #include <consensus/amount.h>          // For CAmount
 #include <governance/common.h>
 #include <interfaces/chain.h>          // For ChainClient
+#include <interfaces/masternode_operator.h>
 #include <pubkey.h>                    // For CKeyID and CScriptID (definitions needed in CTxDestination instantiation)
 #include <script/standard.h>           // For CTxDestination
 #include <support/allocators/secure.h> // For SecureString
@@ -28,6 +29,7 @@
 #include <utility>
 #include <vector>
 
+class CBLSPublicKey;
 class CFeeRate;
 class CGovernanceVote;
 class CKey;
@@ -142,6 +144,22 @@ class Wallet
     //! Sign special transaction payload
     virtual bool signSpecialTxPayload(const uint256& hash, const CKeyID& keyid, std::vector<unsigned char>& vchSig) = 0;
 
+    //! Whether this wallet is a descriptor wallet with exactly one
+    //! mnemonic-backed operator-key source. Legacy wallets are not supported.
+    virtual bool hasMasternodeOperatorKeySource() = 0;
+    //! Derive and permanently consume the lowest operator-key index at or
+    //! above the consumption watermark that is not in use. The watermark is
+    //! persisted before the secret is returned and never rolled back.
+    //! is_in_use may be empty; when set it is queried without wallet locks
+    //! held so the caller can supply interfaces::Node's EVO predicate, and
+    //! issuance scans gap-limit style past every index it reports in use.
+    virtual MasternodeOperatorKeyResult getNewMasternodeOperatorKey(
+        const std::function<bool(const CBLSPublicKey&)>& is_in_use) = 0;
+    //! Re-derive a previously consumed operator key (an index below the
+    //! watermark) by its basic-scheme public key. Read-only; keys never
+    //! exposed are not addressable.
+    virtual MasternodeOperatorKeyResult getMasternodeOperatorKey(const std::vector<unsigned char>& public_key) = 0;
+
     //! Return whether wallet has private key.
     virtual bool isSpendable(const CScript& script) = 0;
     virtual bool isSpendable(const CTxDestination& dest) = 0;
diff --git a/src/wallet/interfaces.cpp b/src/wallet/interfaces.cpp
index 4af755044de8..9f707e6dc5e8 100644
--- a/src/wallet/interfaces.cpp
+++ b/src/wallet/interfaces.cpp
@@ -4,6 +4,7 @@
 
 #include <interfaces/wallet.h>
 
+#include <bls/bls.h>
 #include <chain.h>
 #include <coinjoin/client.h>
 #include <consensus/amount.h>
@@ -239,6 +240,23 @@ class WalletImpl : public Wallet
     {
         return m_wallet->SignSpecialTxPayload(hash, keyid, vchSig);
     }
+    bool hasMasternodeOperatorKeySource() override { return m_wallet->HasMasternodeOperatorKeySource(); }
+    interfaces::MasternodeOperatorKeyResult getNewMasternodeOperatorKey(
+        const std::function<bool(const CBLSPublicKey&)>& is_in_use) override
+    {
+        return m_wallet->GetNewMasternodeOperatorKey(is_in_use);
+    }
+    interfaces::MasternodeOperatorKeyResult getMasternodeOperatorKey(const std::vector<unsigned char>& public_key) override
+    {
+        CBLSPublicKey parsed;
+        parsed.SetBytes(public_key, /*specificLegacyScheme=*/false);
+        if (!parsed.IsValid() || parsed.ToByteVector(/*specificLegacyScheme=*/false) != public_key) {
+            interfaces::MasternodeOperatorKeyResult result;
+            result.status = interfaces::MasternodeOperatorKeyStatus::INVALID_KEY;
+            return result;
+        }
+        return m_wallet->GetMasternodeOperatorKey(parsed);
+    }
     bool isSpendable(const CScript& script) override
     {
         LOCK(m_wallet->cs_wallet);
diff --git a/src/wallet/masternode_operator.h b/src/wallet/masternode_operator.h
new file mode 100644
index 000000000000..98de8dfd7d4f
--- /dev/null
+++ b/src/wallet/masternode_operator.h
@@ -0,0 +1,90 @@
+// Copyright (c) 2026 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_WALLET_MASTERNODE_OPERATOR_H
+#define BITCOIN_WALLET_MASTERNODE_OPERATOR_H
+
+#include <interfaces/masternode_operator.h>
+#include <serialize.h>
+#include <tinyformat.h>
+#include <wallet/hdchain.h>
+
+#include <array>
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace wallet {
+
+/**
+ * Number of derivation indexes kept ahead of the consumption watermark. It is
+ * both the size of the persisted recognition lookahead (so provider
+ * transactions seen during sync can be matched without the seed) and the
+ * BIP44-style gap limit at issuance: candidates are scanned against the
+ * current masternode list until this many consecutive indexes are not in use,
+ * and the key issued is the first index above every in-use hit.
+ */
+inline constexpr uint32_t MASTERNODE_OPERATOR_GAP_LIMIT{50};
+/** Sanity bound on derivation depth; issuance and recognition never walk past it. */
+inline constexpr uint32_t MASTERNODE_OPERATOR_MAX_INDEX{1000000};
+inline constexpr uint32_t MASTERNODE_OPERATOR_PURPOSE{BIP32_PURPOSE_FEATURE};
+inline constexpr uint32_t MASTERNODE_OPERATOR_PROVIDER_FEATURE{3};
+inline constexpr uint32_t MASTERNODE_OPERATOR_SUBFEATURE{3};
+
+using MasternodeOperatorKeyStatus = interfaces::MasternodeOperatorKeyStatus;
+
+//! DashSync-compatible operator-key path m/9'/coin'/3'/3'/index. The first
+//! four levels are hardened; the leaf is not.
+inline std::array<uint32_t, 5> MasternodeOperatorDerivationPath(uint32_t coin_type, uint32_t index)
+{
+    constexpr uint32_t hardened{0x80000000};
+    assert(index < hardened);
+    return {
+        hardened | MASTERNODE_OPERATOR_PURPOSE,
+        hardened | coin_type,
+        hardened | MASTERNODE_OPERATOR_PROVIDER_FEATURE,
+        hardened | MASTERNODE_OPERATOR_SUBFEATURE,
+        index,
+    };
+}
+
+inline std::string MasternodeOperatorKeyPath(uint32_t coin_type, uint32_t index)
+{
+    const auto path{MasternodeOperatorDerivationPath(coin_type, index)};
+    constexpr uint32_t hardened{0x80000000};
+    return strprintf("m/%d'/%d'/%d'/%d'/%d", path[0] & ~hardened, path[1] & ~hardened, path[2] & ~hardened,
+                     path[3] & ~hardened, path[4]);
+}
+
+/** Advisory consumption watermark: every derivation index below next_index is
+ *  permanently consumed (issuance is strictly lowest-index-first, so the
+ *  consumed set is always a prefix). Tagged with the seed-source identifier
+ *  so a record left behind by a different seed is ignored rather than
+ *  trusted. Holds no secret. */
+struct MasternodeOperatorWatermark {
+    std::vector<unsigned char> source_id;
+    uint32_t next_index{0};
+
+    SERIALIZE_METHODS(MasternodeOperatorWatermark, obj) { READWRITE(obj.source_id, obj.next_index); }
+};
+
+/** Advisory recognition lookahead: the basic-scheme public keys of the
+ *  derivation indexes starting at base_index (normally the watermark), kept
+ *  so the transaction-sync path can match provider transactions against
+ *  upcoming keys without the seed - including while the wallet is locked.
+ *  Rebuilt from the seed whenever it goes stale; holds no secret. */
+struct MasternodeOperatorLookahead {
+    std::vector<unsigned char> source_id;
+    uint32_t base_index{0};
+    std::vector<std::vector<unsigned char>> public_keys;
+
+    SERIALIZE_METHODS(MasternodeOperatorLookahead, obj)
+    {
+        READWRITE(obj.source_id, obj.base_index, obj.public_keys);
+    }
+};
+
+} // namespace wallet
+
+#endif // BITCOIN_WALLET_MASTERNODE_OPERATOR_H
diff --git a/src/wallet/rpc/wallet.cpp b/src/wallet/rpc/wallet.cpp
index ff052cbc07f6..78a2dacbccfb 100644
--- a/src/wallet/rpc/wallet.cpp
+++ b/src/wallet/rpc/wallet.cpp
@@ -412,6 +412,23 @@ static RPCHelpMan upgradetohd()
             }
         }
 
+        // A user-supplied mnemonic is a restore: provider transactions using
+        // its derived operator keys may already exist in history. Build the
+        // recognition lookahead while the freshly installed seed is still
+        // accessible - an encrypted wallet is relocked below - so a rescan
+        // that follows can match them. A generated mnemonic is new entropy
+        // that cannot appear in history.
+        if (!generate_mnemonic) {
+            const auto lookahead_status{pwallet->TopUpMasternodeOperatorLookahead()};
+            // NOT_SUPPORTED is the norm here: legacy wallets have no
+            // operator-key source.
+            if (lookahead_status != MasternodeOperatorKeyStatus::SUCCESS &&
+                lookahead_status != MasternodeOperatorKeyStatus::NOT_SUPPORTED) {
+                pwallet->WalletLogPrintf("upgradetohd: failed to build operator-key lookahead (status %d)\n",
+                                         static_cast<int>(lookahead_status));
+            }
+        }
+
         if (pwallet->IsCrypted()) {
             // Relock encrypted wallet
             pwallet->Lock();
diff --git a/src/wallet/salvage.cpp b/src/wallet/salvage.cpp
index fdae721b7667..39bde56de379 100644
--- a/src/wallet/salvage.cpp
+++ b/src/wallet/salvage.cpp
@@ -20,7 +20,7 @@ typedef std::pair<std::vector<unsigned char>, std::vector<unsigned char> > KeyVa
 
 static bool KeyFilter(const std::string& type)
 {
-    return WalletBatch::IsKeyType(type) || type == DBKeys::HDCHAIN;
+    return WalletBatch::IsKeyType(type) || type == DBKeys::HDCHAIN || type == DBKeys::MASTERNODE_OPERATOR_NEXT;
 }
 
 bool RecoverDatabaseFile(const ArgsManager& args, const fs::path& file_path, bilingual_str& error, std::vector<bilingual_str>& warnings)
diff --git a/src/wallet/scriptpubkeyman.cpp b/src/wallet/scriptpubkeyman.cpp
index fcd9bbd5c6aa..c5da9779faaa 100644
--- a/src/wallet/scriptpubkeyman.cpp
+++ b/src/wallet/scriptpubkeyman.cpp
@@ -3,12 +3,14 @@
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
 #include <key_io.h>
+#include <bls/bls.h>
 #include <chainparams.h>
 #include <logging.h>
 #include <messagesigner.h>
 #include <script/descriptor.h>
 #include <script/sign.h>
 #include <shutdown.h>
+#include <support/cleanse.h>
 #include <util/bip32.h>
 #include <util/strencodings.h>
 #include <util/system.h>
@@ -36,6 +38,35 @@ util::Result<CTxDestination> LegacyScriptPubKeyMan::GetNewDestination()
 typedef std::vector<unsigned char> valtype;
 
 namespace {
+MasternodeOperatorKeyStatus DeriveMasternodeOperatorChildren(
+    const SecureVector& seed, uint32_t coin_type, uint32_t begin, uint32_t end,
+    const std::function<bool(uint32_t index, const CBLSSecretKey& secret)>& callback)
+{
+    if (seed.empty() || begin >= end || end > MASTERNODE_OPERATOR_MAX_INDEX) {
+        return MasternodeOperatorKeyStatus::INVALID_KEY;
+    }
+
+    try {
+        // Expand the seed and derive the four hardened account levels once for
+        // the whole walk; each index then only costs one leaf-child derivation.
+        bls::ExtendedPrivateKey account{bls::ExtendedPrivateKey::FromSeed(bls::Bytes{seed.data(), seed.size()})};
+        const auto path{MasternodeOperatorDerivationPath(coin_type, begin)};
+        for (size_t level{0}; level + 1 < path.size(); ++level) {
+            account = account.PrivateChild(path[level], /*fLegacy=*/true);
+        }
+        for (uint32_t index{begin}; index < end; ++index) {
+            SecureVector secret_bytes(CBLSSecretKey::SerSize);
+            account.PrivateChild(index, /*fLegacy=*/true).GetPrivateKey().Serialize(secret_bytes.data());
+            const CBLSSecretKey secret{Span<const unsigned char>{secret_bytes.data(), secret_bytes.size()}};
+            if (!secret.IsValid()) return MasternodeOperatorKeyStatus::DERIVATION_ERROR;
+            if (!callback(index, secret)) break;
+        }
+    } catch (const std::exception& e) {
+        LogPrintf("%s: BLS derivation failed: %s\n", __func__, e.what());
+        return MasternodeOperatorKeyStatus::DERIVATION_ERROR;
+    }
+    return MasternodeOperatorKeyStatus::SUCCESS;
+}
 
 /**
  * This is an enum that tracks the execution context of a script, similar to
@@ -768,6 +799,20 @@ bool LegacyScriptPubKeyMan::SignSpecialTxPayload(const uint256& hash, const CKey
     return CHashSigner::SignHash(hash, key, vchSig);
 }
 
+MasternodeOperatorKeyStatus ScriptPubKeyMan::DeriveMasternodeOperatorKey(uint32_t coin_type, uint32_t index,
+                                                                         CBLSSecretKey& secret) const
+{
+    secret.Reset();
+    if (index >= MASTERNODE_OPERATOR_MAX_INDEX) return MasternodeOperatorKeyStatus::INVALID_KEY;
+    const auto status{DeriveMasternodeOperatorKeys(coin_type, index, index + 1,
+                                                   [&secret](uint32_t, const CBLSSecretKey& derived) {
+                                                       secret = derived;
+                                                       return false;
+                                                   })};
+    if (status != MasternodeOperatorKeyStatus::SUCCESS) return status;
+    return secret.IsValid() ? MasternodeOperatorKeyStatus::SUCCESS : MasternodeOperatorKeyStatus::DERIVATION_ERROR;
+}
+
 TransactionError LegacyScriptPubKeyMan::FillPSBT(PartiallySignedTransaction& psbtx, const PrecomputedTransactionData& txdata, int sighash_type, bool sign, bool bip32derivs, int* n_signed, bool finalize) const
 {
     if (n_signed) {
@@ -2716,6 +2761,58 @@ bool DescriptorScriptPubKeyMan::SignSpecialTxPayload(const uint256& hash, const
     return CHashSigner::SignHash(hash, key, vchSig);
 }
 
+MasternodeOperatorKeySourceStatus DescriptorScriptPubKeyMan::GetMasternodeOperatorKeySource(
+    std::vector<unsigned char>& identifier) const
+{
+    LOCK(cs_desc_man);
+
+    std::vector<CKeyID> seed_ids;
+    for (const auto& [id, mnemonic] : m_mnemonics) {
+        if (!mnemonic.first.empty()) seed_ids.push_back(id);
+    }
+    for (const auto& [id, mnemonic] : m_crypted_mnemonics) {
+        if (!mnemonic.first.empty()) seed_ids.push_back(id);
+    }
+    if (seed_ids.empty()) return MasternodeOperatorKeySourceStatus::NONE;
+    if (seed_ids.size() != 1) return MasternodeOperatorKeySourceStatus::AMBIGUOUS;
+
+    identifier.assign(1, 1);
+    identifier.insert(identifier.end(), seed_ids.front().begin(), seed_ids.front().end());
+    return MasternodeOperatorKeySourceStatus::AVAILABLE;
+}
+
+MasternodeOperatorKeyStatus DescriptorScriptPubKeyMan::DeriveMasternodeOperatorKeys(
+    uint32_t coin_type, uint32_t begin, uint32_t end,
+    const std::function<bool(uint32_t index, const CBLSSecretKey& secret)>& callback) const
+{
+    std::vector<unsigned char> identifier;
+    if (GetMasternodeOperatorKeySource(identifier) != MasternodeOperatorKeySourceStatus::AVAILABLE) {
+        return MasternodeOperatorKeyStatus::NOT_SUPPORTED;
+    }
+
+    SecureString mnemonic;
+    SecureString passphrase;
+    if (!GetMnemonicString(mnemonic, passphrase) || mnemonic.empty() || !CMnemonic::Check(mnemonic)) {
+        return m_storage.IsLocked(false) ? MasternodeOperatorKeyStatus::WALLET_LOCKED
+                                         : MasternodeOperatorKeyStatus::DERIVATION_ERROR;
+    }
+
+    SecureVector seed;
+    CMnemonic::ToSeed(mnemonic, passphrase, seed);
+    CExtKey master;
+    master.SetSeed(MakeByteSpan(seed));
+    const bool master_valid{master.key.IsValid()};
+    const CKeyID master_id{master_valid ? master.key.GetPubKey().GetID() : CKeyID{}};
+    memory_cleanse(master.chaincode.data(), master.chaincode.size());
+    if (identifier.size() != 1 + uint160::size()) return MasternodeOperatorKeyStatus::DERIVATION_ERROR;
+    uint160 source_id;
+    std::copy(identifier.begin() + 1, identifier.end(), source_id.begin());
+    if (!master_valid || master_id != CKeyID{source_id}) {
+        return MasternodeOperatorKeyStatus::DERIVATION_ERROR;
+    }
+    return DeriveMasternodeOperatorChildren(seed, coin_type, begin, end, callback);
+}
+
 TransactionError DescriptorScriptPubKeyMan::FillPSBT(PartiallySignedTransaction& psbtx, const PrecomputedTransactionData& txdata, int sighash_type, bool sign, bool bip32derivs, int* n_signed, bool finalize) const
 {
     if (n_signed) {
diff --git a/src/wallet/scriptpubkeyman.h b/src/wallet/scriptpubkeyman.h
index 2cf6805ff52d..3f96eb29928f 100644
--- a/src/wallet/scriptpubkeyman.h
+++ b/src/wallet/scriptpubkeyman.h
@@ -17,6 +17,7 @@
 #include <wallet/crypter.h>
 #include <wallet/hdchain.h>
 #include <wallet/ismine.h>
+#include <wallet/masternode_operator.h>
 #include <wallet/walletdb.h>
 #include <wallet/walletutil.h>
 
@@ -25,7 +26,15 @@
 #include <functional>
 #include <optional>
 
+class CBLSSecretKey;
+
 namespace wallet {
+enum class MasternodeOperatorKeySourceStatus {
+    NONE,
+    AVAILABLE,
+    AMBIGUOUS,
+};
+
 // Wallet storage things that ScriptPubKeyMans need in order to be able to store things to the wallet database.
 // It provides access to things that are part of the entire wallet and not specific to a ScriptPubKeyMan such as
 // wallet flags, wallet version, encryption keys, encryption status, and the database itself. This allows a
@@ -234,6 +243,24 @@ class ScriptPubKeyMan
     /** Sign a message with the given script */
     virtual SigningResult SignMessage(const std::string& message, const PKHash& pkhash, std::string& str_sig) const { return SigningResult::SIGNING_FAILED; };
     virtual bool SignSpecialTxPayload(const uint256& hash, const CKeyID& keyid, std::vector<unsigned char>& vchSig) const { return false; }
+    /** Return an unlock-free identifier for this manager's supported operator-key
+     *  source. Managers backed by the same mnemonic return the same identifier. */
+    virtual MasternodeOperatorKeySourceStatus GetMasternodeOperatorKeySource(std::vector<unsigned char>& identifier) const
+    {
+        return MasternodeOperatorKeySourceStatus::NONE;
+    }
+    /** Derive the DashSync-compatible operator children [begin, end) from a single
+     *  seed expansion, invoking the callback per child without exposing root
+     *  material. A callback returning false stops the walk early. */
+    virtual MasternodeOperatorKeyStatus DeriveMasternodeOperatorKeys(
+        uint32_t coin_type, uint32_t begin, uint32_t end,
+        const std::function<bool(uint32_t index, const CBLSSecretKey& secret)>& callback) const
+    {
+        return MasternodeOperatorKeyStatus::NOT_SUPPORTED;
+    }
+    /** Derive a single operator child. */
+    MasternodeOperatorKeyStatus DeriveMasternodeOperatorKey(uint32_t coin_type, uint32_t index,
+                                                            CBLSSecretKey& secret) const;
     /** Adds script and derivation path information to a PSBT, and optionally signs it. */
     virtual TransactionError FillPSBT(PartiallySignedTransaction& psbt, const PrecomputedTransactionData& txdata, int sighash_type = 1 /* SIGHASH_ALL */, bool sign = true, bool bip32derivs = false, int* n_signed = nullptr, bool finalize = true) const { return TransactionError::INVALID_PSBT; }
 
@@ -643,6 +670,10 @@ class DescriptorScriptPubKeyMan : public ScriptPubKeyMan
     bool SignTransaction(CMutableTransaction& tx, const std::map<COutPoint, Coin>& coins, int sighash, std::map<int, bilingual_str>& input_errors) const override;
     SigningResult SignMessage(const std::string& message, const PKHash& pkhash, std::string& str_sig) const override;
     bool SignSpecialTxPayload(const uint256& hash, const CKeyID& keyid, std::vector<unsigned char>& vchSig) const override;
+    MasternodeOperatorKeySourceStatus GetMasternodeOperatorKeySource(std::vector<unsigned char>& identifier) const override;
+    MasternodeOperatorKeyStatus DeriveMasternodeOperatorKeys(
+        uint32_t coin_type, uint32_t begin, uint32_t end,
+        const std::function<bool(uint32_t index, const CBLSSecretKey& secret)>& callback) const override;
     TransactionError FillPSBT(PartiallySignedTransaction& psbt, const PrecomputedTransactionData& txdata, int sighash_type = 1 /* SIGHASH_ALL */, bool sign = true, bool bip32derivs = false, int* n_signed = nullptr, bool finalize = true) const override;
 
     uint256 GetID() const override;
diff --git a/src/wallet/test/masternode_operator_tests.cpp b/src/wallet/test/masternode_operator_tests.cpp
new file mode 100644
index 000000000000..c351d21c2975
--- /dev/null
+++ b/src/wallet/test/masternode_operator_tests.cpp
@@ -0,0 +1,634 @@
+// Copyright (c) 2026 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <bls/bls.h>
+#include <chain.h>
+#include <clientversion.h>
+#include <evo/netinfo.h>
+#include <evo/providertx.h>
+#include <evo/specialtx.h>
+#include <evo/types.h>
+#include <interfaces/wallet.h>
+#include <streams.h>
+#include <support/cleanse.h>
+#include <util/strencodings.h>
+#include <util/time.h>
+#include <validation.h>
+#include <wallet/bip39.h>
+#include <wallet/hdchain.h>
+#include <wallet/masternode_operator.h>
+#include <wallet/scriptpubkeyman.h>
+#include <wallet/test/wallet_test_fixture.h>
+#include <wallet/wallet.h>
+#include <wallet/walletdb.h>
+
+#include <boost/test/unit_test.hpp>
+
+#include <array>
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace wallet {
+namespace {
+
+// The known-answer vectors are cross-checked against DashSync: the seed phrase
+// and the expected legacy-serialized operator public key at m/9'/1'/3'/3'/0
+// appear in the hardcoded ProRegTx payloads of
+// dashsync-iOS/Example/Tests/DSProviderTransactionsTests.m
+// (testCollateralProviderRegistrationTransaction and
+// testNoCollateralProviderRegistrationTransaction).
+const SecureString DASHSYNC_MNEMONIC{
+    "enemy check owner stumble unaware debris suffer peanut good fabric bleak outside"};
+const SecureString SECOND_MNEMONIC{
+    "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about"};
+const SecureString MNEMONIC_PASSPHRASE{"Dash operator key test"};
+const std::string DASHSYNC_OPERATOR_SECRET{"344e7bf67fddf1c2d2f629f2392ce2b4af99393cd8a4c70d4bbaef7aaf4c364b"};
+const std::string DASHSYNC_MAINNET_OPERATOR_SECRET{"0461b8370ac28e7d7c453ab769d6edc97e9a79e400ae100bfbbf7ea9d834fd2c"};
+const std::string DASHSYNC_OPERATOR_PUBLIC_KEY_LEGACY{
+    "157b10706659e25eb362b5d902d809f9160b1688e201ee6e94b40f9b5062d7074683ef05a2d5efb7793c47059c878dfa"};
+
+void SetupMnemonicWallet(CWallet& wallet, const SecureString& mnemonic = DASHSYNC_MNEMONIC,
+                         const SecureString& passphrase = {})
+{
+    LOCK(wallet.cs_wallet);
+    wallet.SetWalletFlag(WALLET_FLAG_DESCRIPTORS);
+    wallet.SetupDescriptorScriptPubKeyMans(mnemonic, passphrase);
+}
+
+void SetupLegacyMnemonicWallet(CWallet& wallet)
+{
+    CHDChain chain;
+    BOOST_REQUIRE(chain.SetMnemonic(DASHSYNC_MNEMONIC, {}, /*fUpdateID=*/true));
+    chain.AddAccount();
+    LOCK(wallet.cs_wallet);
+    BOOST_REQUIRE(wallet.GetOrCreateLegacyScriptPubKeyMan()->AddHDChainSingle(chain));
+}
+
+//! Independently derive the first `count` operator public keys the DashSync way.
+std::vector<std::vector<unsigned char>> DashSyncPublicKeys(uint32_t count)
+{
+    SecureVector seed;
+    CMnemonic::ToSeed(DASHSYNC_MNEMONIC, {}, seed);
+    constexpr uint32_t hardened{0x80000000};
+    const bls::ExtendedPrivateKey account{bls::ExtendedPrivateKey::FromSeed(bls::Bytes{seed.data(), seed.size()})
+                                              .PrivateChild(hardened | MASTERNODE_OPERATOR_PURPOSE, /*fLegacy=*/true)
+                                              .PrivateChild(hardened | 1, /*fLegacy=*/true)
+                                              .PrivateChild(hardened | MASTERNODE_OPERATOR_PROVIDER_FEATURE,
+                                                            /*fLegacy=*/true)
+                                              .PrivateChild(hardened | MASTERNODE_OPERATOR_SUBFEATURE,
+                                                            /*fLegacy=*/true)};
+    memory_cleanse(seed.data(), seed.size());
+
+    std::vector<std::vector<unsigned char>> public_keys;
+    public_keys.reserve(count);
+    for (uint32_t index{0}; index < count; ++index) {
+        auto secret_bytes{account.PrivateChild(index, /*fLegacy=*/true).GetPrivateKey().SerializeToArray()};
+        const CBLSSecretKey secret{Span<const unsigned char>{secret_bytes.data(), secret_bytes.size()}};
+        memory_cleanse(secret_bytes.data(), secret_bytes.size());
+        BOOST_REQUIRE(secret.IsValid());
+        public_keys.emplace_back(secret.GetPublicKey().ToByteVector(/*specificLegacyScheme=*/false));
+    }
+    return public_keys;
+}
+
+using interfaces::MasternodeOperatorKeyStatus;
+
+std::optional<MasternodeOperatorWatermark> ReadWatermarkRecord(CWallet& wallet)
+{
+    MasternodeOperatorWatermark watermark;
+    WalletBatch batch{wallet.GetDatabase()};
+    if (!batch.ReadMasternodeOperatorWatermark(watermark)) return std::nullopt;
+    return watermark;
+}
+
+std::optional<MasternodeOperatorLookahead> ReadLookaheadRecord(CWallet& wallet)
+{
+    MasternodeOperatorLookahead lookahead;
+    WalletBatch batch{wallet.GetDatabase()};
+    if (!batch.ReadMasternodeOperatorLookahead(lookahead)) return std::nullopt;
+    return lookahead;
+}
+
+MasternodeOperatorKeyStatus TopUpLookahead(CWallet& wallet)
+{
+    LOCK(wallet.cs_wallet);
+    return wallet.TopUpMasternodeOperatorLookahead();
+}
+
+std::vector<unsigned char> RandomOperatorKeyBytes()
+{
+    CBLSSecretKey secret;
+    secret.MakeNewKey();
+    return secret.GetPublicKey().ToByteVector(/*specificLegacyScheme=*/false);
+}
+
+CBLSPublicKey ParseBasic(const std::vector<unsigned char>& bytes)
+{
+    CBLSPublicKey key;
+    key.SetBytes(bytes, /*specificLegacyScheme=*/false);
+    BOOST_REQUIRE(key.IsValid());
+    return key;
+}
+
+CTransactionRef BuildProRegTx(const CBLSPublicKey& operator_key, bool legacy_encoding)
+{
+    CProRegTx payload;
+    payload.nVersion = legacy_encoding ? ProTxVersion::LegacyBLS : ProTxVersion::BasicBLS;
+    payload.netInfo = NetInfoInterface::MakeNetInfo(payload.nVersion);
+    payload.pubKeyOperator.Set(operator_key, legacy_encoding);
+
+    CMutableTransaction tx;
+    tx.nVersion = 3;
+    tx.nType = TRANSACTION_PROVIDER_REGISTER;
+    SetTxPayload(tx, payload);
+    return MakeTransactionRef(tx);
+}
+
+CTransactionRef BuildProUpRegTx(const CBLSPublicKey& operator_key, bool legacy_encoding)
+{
+    CProUpRegTx payload;
+    payload.nVersion = legacy_encoding ? ProTxVersion::LegacyBLS : ProTxVersion::BasicBLS;
+    payload.pubKeyOperator.Set(operator_key, legacy_encoding);
+
+    CMutableTransaction tx;
+    tx.nVersion = 3;
+    tx.nType = TRANSACTION_PROVIDER_UPDATE_REGISTRAR;
+    SetTxPayload(tx, payload);
+    return MakeTransactionRef(tx);
+}
+
+struct MasternodeOperatorTestingSetup : public WalletTestingSetup {
+    MasternodeOperatorTestingSetup() :
+        WalletTestingSetup(CBaseChainParams::REGTEST)
+    {
+        gArgs.ForceSetArg("-keypool", "1");
+    }
+
+    ~MasternodeOperatorTestingSetup() { gArgs.ForceRemoveArg("keypool"); }
+
+    std::shared_ptr<CWallet> MakeWallet(std::unique_ptr<WalletDatabase> database = CreateMockWalletDatabase())
+    {
+        auto wallet{std::make_shared<CWallet>(m_node.chain.get(), m_coinjoin_loader.get(), "", m_args,
+                                              std::move(database))};
+        BOOST_REQUIRE(wallet->LoadWallet() == DBErrors::LOAD_OK);
+        return wallet;
+    }
+
+    std::shared_ptr<CWallet> MakeNamedWallet(const std::string& name, bool existing)
+    {
+        DatabaseOptions options;
+        options.require_create = !existing;
+        options.require_existing = existing;
+        DatabaseStatus status;
+        bilingual_str error;
+        auto database{MakeWalletDatabase(name, options, status, error)};
+        BOOST_REQUIRE_MESSAGE(database, error.original);
+        auto wallet{
+            std::make_shared<CWallet>(m_node.chain.get(), m_coinjoin_loader.get(), name, m_args, std::move(database))};
+        BOOST_REQUIRE(wallet->LoadWallet() == DBErrors::LOAD_OK);
+        return wallet;
+    }
+
+    std::unique_ptr<interfaces::Wallet> MakeWalletInterface(const std::shared_ptr<CWallet>& wallet)
+    {
+        return interfaces::MakeWallet(*Assert(m_wallet_loader->context()), wallet);
+    }
+};
+
+//! Database whose writes can be toggled to fail, for fail-closed checks.
+class ToggleFailBatch final : public DatabaseBatch
+{
+private:
+    bool& m_write_success;
+    bool ReadKey(CDataStream&&, CDataStream&) override { return false; }
+    bool WriteKey(CDataStream&&, CDataStream&&, bool) override { return m_write_success; }
+    bool EraseKey(CDataStream&&) override { return m_write_success; }
+    bool HasKey(CDataStream&&) override { return false; }
+    bool ErasePrefix(Span<const std::byte>) override { return m_write_success; }
+
+public:
+    explicit ToggleFailBatch(bool& write_success) : m_write_success(write_success) {}
+    void Flush() override {}
+    void Close() override {}
+    bool StartCursor() override { return true; }
+    bool ReadAtCursor(CDataStream&, CDataStream&, bool& complete) override
+    {
+        complete = true;
+        return true;
+    }
+    void CloseCursor() override {}
+    bool TxnBegin() override { return true; }
+    bool TxnCommit() override { return true; }
+    bool TxnAbort() override { return true; }
+};
+
+class ToggleFailDatabase final : public WalletDatabase
+{
+public:
+    bool write_success{true};
+
+    void Open() override {}
+    void AddRef() override {}
+    void RemoveRef() override {}
+    bool Rewrite(const char*) override { return true; }
+    bool Backup(const std::string&) const override { return true; }
+    void Flush() override {}
+    void Close() override {}
+    bool PeriodicFlush() override { return true; }
+    void IncrementUpdateCounter() override { ++nUpdateCounter; }
+    void ReloadDbEnv() override {}
+    std::string Filename() override { return "toggle-fail"; }
+    std::string Format() override { return "toggle-fail"; }
+    std::unique_ptr<DatabaseBatch> MakeBatch(bool) override { return std::make_unique<ToggleFailBatch>(write_success); }
+};
+
+} // namespace
+
+BOOST_FIXTURE_TEST_SUITE(masternode_operator_tests, MasternodeOperatorTestingSetup)
+
+BOOST_AUTO_TEST_CASE(watermark_known_answer)
+{
+    const auto expected{DashSyncPublicKeys(3)};
+    auto wallet{MakeWallet()};
+    SetupMnemonicWallet(*wallet);
+    auto interface{MakeWalletInterface(wallet)};
+    BOOST_REQUIRE(interface->hasMasternodeOperatorKeySource());
+
+    auto first{interface->getNewMasternodeOperatorKey({})};
+    BOOST_REQUIRE(first.status == MasternodeOperatorKeyStatus::SUCCESS);
+    BOOST_CHECK_EQUAL(first.key.path, "m/9'/1'/3'/3'/0");
+    BOOST_CHECK_EQUAL(HexStr(first.key.secret_key), DASHSYNC_OPERATOR_SECRET);
+    BOOST_CHECK(first.key.public_key == expected[0]);
+    const CBLSSecretKey first_secret{
+        Span<const unsigned char>{first.key.secret_key.data(), first.key.secret_key.size()}};
+    BOOST_REQUIRE(first_secret.IsValid());
+    BOOST_CHECK_EQUAL(HexStr(first_secret.GetPublicKey().ToByteVector(/*specificLegacyScheme=*/true)),
+                      DASHSYNC_OPERATOR_PUBLIC_KEY_LEGACY);
+
+    // The consumption watermark was persisted, and the recognition
+    // lookahead follows it: gap-limit keys starting at the watermark.
+    const auto watermark{ReadWatermarkRecord(*wallet)};
+    BOOST_REQUIRE(watermark.has_value());
+    BOOST_CHECK_EQUAL(watermark->next_index, 1U);
+    const auto lookahead{ReadLookaheadRecord(*wallet)};
+    BOOST_REQUIRE(lookahead.has_value());
+    BOOST_CHECK_EQUAL(lookahead->base_index, 1U);
+    BOOST_CHECK_EQUAL(lookahead->public_keys.size(), MASTERNODE_OPERATOR_GAP_LIMIT);
+    BOOST_CHECK(lookahead->public_keys[0] == expected[1]);
+    BOOST_CHECK(lookahead->source_id == watermark->source_id);
+
+    // Consumption is permanent: the next key is the next index.
+    auto second{interface->getNewMasternodeOperatorKey({})};
+    BOOST_REQUIRE(second.status == MasternodeOperatorKeyStatus::SUCCESS);
+    BOOST_CHECK_EQUAL(second.key.path, "m/9'/1'/3'/3'/1");
+    BOOST_CHECK(second.key.public_key == expected[1]);
+    BOOST_CHECK_EQUAL(ReadWatermarkRecord(*wallet)->next_index, 2U);
+}
+
+BOOST_AUTO_TEST_CASE(mainnet_path_and_mnemonic_passphrase)
+{
+    auto wallet{MakeWallet()};
+    SetupMnemonicWallet(*wallet);
+    CBLSSecretKey mainnet_secret;
+    {
+        LOCK(wallet->cs_wallet);
+        bool derived{false};
+        for (ScriptPubKeyMan* spk_man : wallet->GetAllScriptPubKeyMans()) {
+            std::vector<unsigned char> source_id;
+            if (spk_man->GetMasternodeOperatorKeySource(source_id) !=
+                MasternodeOperatorKeySourceStatus::AVAILABLE) {
+                continue;
+            }
+            BOOST_REQUIRE(spk_man->DeriveMasternodeOperatorKey(/*coin_type=*/5, /*index=*/0, mainnet_secret) ==
+                          MasternodeOperatorKeyStatus::SUCCESS);
+            derived = true;
+            break;
+        }
+        BOOST_REQUIRE(derived);
+    }
+    BOOST_CHECK_EQUAL(HexStr(mainnet_secret.ToByteVector(/*specificLegacyScheme=*/false)),
+                      DASHSYNC_MAINNET_OPERATOR_SECRET);
+    BOOST_CHECK_EQUAL(MasternodeOperatorKeyPath(/*coin_type=*/5, /*index=*/0), "m/9'/5'/3'/3'/0");
+
+    auto protected_wallet{MakeWallet()};
+    SetupMnemonicWallet(*protected_wallet, DASHSYNC_MNEMONIC, MNEMONIC_PASSPHRASE);
+    auto interface{MakeWalletInterface(protected_wallet)};
+    auto protected_key{interface->getNewMasternodeOperatorKey({})};
+    BOOST_REQUIRE(protected_key.status == MasternodeOperatorKeyStatus::SUCCESS);
+    // A BIP39 passphrase changes the seed, and with it every derived key.
+    BOOST_CHECK(HexStr(protected_key.key.secret_key) != DASHSYNC_OPERATOR_SECRET);
+}
+
+BOOST_AUTO_TEST_CASE(exact_recovery_returns_consumed_keys_only)
+{
+    auto wallet{MakeWallet()};
+    SetupMnemonicWallet(*wallet);
+    auto interface{MakeWalletInterface(wallet)};
+
+    const auto expected{DashSyncPublicKeys(6)};
+    auto first{interface->getNewMasternodeOperatorKey({})};
+    BOOST_REQUIRE(first.status == MasternodeOperatorKeyStatus::SUCCESS);
+    auto second{interface->getNewMasternodeOperatorKey({})};
+    BOOST_REQUIRE(second.status == MasternodeOperatorKeyStatus::SUCCESS);
+
+    // Recovery of consumed keys re-derives the same secrets, repeatably.
+    auto recovered{interface->getMasternodeOperatorKey(expected[0])};
+    BOOST_REQUIRE(recovered.status == MasternodeOperatorKeyStatus::SUCCESS);
+    BOOST_CHECK_EQUAL(recovered.key.path, "m/9'/1'/3'/3'/0");
+    BOOST_CHECK(recovered.key.secret_key == first.key.secret_key);
+    auto again{interface->getMasternodeOperatorKey(expected[0])};
+    BOOST_REQUIRE(again.status == MasternodeOperatorKeyStatus::SUCCESS);
+    BOOST_CHECK(again.key.secret_key == first.key.secret_key);
+
+    // Exposure equals consumption: a derivable key above the watermark has
+    // never been exposed, so it is not addressable.
+    BOOST_CHECK(interface->getMasternodeOperatorKey(expected[5]).status == MasternodeOperatorKeyStatus::NOT_FOUND);
+    // Recovery is read-only: the watermark did not move.
+    BOOST_CHECK_EQUAL(ReadWatermarkRecord(*wallet)->next_index, 2U);
+
+    BOOST_CHECK(interface->getMasternodeOperatorKey(RandomOperatorKeyBytes()).status ==
+                MasternodeOperatorKeyStatus::NOT_FOUND);
+    BOOST_CHECK(interface->getMasternodeOperatorKey({0x01, 0x02, 0x03}).status ==
+                MasternodeOperatorKeyStatus::INVALID_KEY);
+}
+
+BOOST_AUTO_TEST_CASE(sync_hook_advances_watermark)
+{
+    // A restored wallet: same mnemonic, empty database. Feeding provider
+    // transactions through the sync path must advance the watermark past the
+    // matched indexes, regardless of the wire encoding of the operator key.
+    auto wallet{MakeWallet()};
+    SetupMnemonicWallet(*wallet);
+    const auto expected{DashSyncPublicKeys(4)};
+
+    // Without a lookahead nothing can be matched: recognition is best-effort.
+    wallet->transactionAddedToMempool(BuildProRegTx(ParseBasic(expected[0]), /*legacy_encoding=*/true), GetTime());
+    BOOST_CHECK(!ReadWatermarkRecord(*wallet).has_value());
+
+    BOOST_REQUIRE(TopUpLookahead(*wallet) == MasternodeOperatorKeyStatus::SUCCESS);
+    wallet->transactionAddedToMempool(BuildProRegTx(ParseBasic(expected[0]), /*legacy_encoding=*/true), GetTime());
+    BOOST_CHECK_EQUAL(ReadWatermarkRecord(*wallet)->next_index, 1U);
+
+    // A hit above the watermark consumes every index below it too: issuance
+    // is lowest-first, so index 1 must have been handed out before index 2.
+    wallet->transactionAddedToMempool(BuildProUpRegTx(ParseBasic(expected[2]), /*legacy_encoding=*/false), GetTime());
+    BOOST_CHECK_EQUAL(ReadWatermarkRecord(*wallet)->next_index, 3U);
+
+    // Foreign operator keys and keys below the watermark change nothing.
+    wallet->transactionAddedToMempool(BuildProRegTx(ParseBasic(RandomOperatorKeyBytes()), /*legacy_encoding=*/false),
+                                      GetTime());
+    wallet->transactionAddedToMempool(BuildProRegTx(ParseBasic(expected[0]), /*legacy_encoding=*/false), GetTime());
+    BOOST_CHECK_EQUAL(ReadWatermarkRecord(*wallet)->next_index, 3U);
+
+    auto interface{MakeWalletInterface(wallet)};
+    auto next{interface->getNewMasternodeOperatorKey({})};
+    BOOST_REQUIRE(next.status == MasternodeOperatorKeyStatus::SUCCESS);
+    BOOST_CHECK_EQUAL(next.key.path, "m/9'/1'/3'/3'/3");
+    BOOST_CHECK(next.key.public_key == expected[3]);
+}
+
+BOOST_AUTO_TEST_CASE(predicate_scans_past_active_keys)
+{
+    auto wallet{MakeWallet()};
+    SetupMnemonicWallet(*wallet);
+    auto interface{MakeWalletInterface(wallet)};
+
+    const auto expected{DashSyncPublicKeys(3)};
+    std::vector<std::vector<unsigned char>> queried;
+    auto result{interface->getNewMasternodeOperatorKey([&](const CBLSPublicKey& candidate) {
+        const auto bytes{candidate.ToByteVector(/*specificLegacyScheme=*/false)};
+        queried.push_back(bytes);
+        return bytes == expected[0];
+    })};
+    BOOST_REQUIRE(result.status == MasternodeOperatorKeyStatus::SUCCESS);
+    BOOST_CHECK_EQUAL(result.key.path, "m/9'/1'/3'/3'/1");
+    // The scan starts at the watermark, visits candidates in index order and
+    // stops after a full gap of not-in-use indexes above the last hit.
+    BOOST_REQUIRE_EQUAL(queried.size(), MASTERNODE_OPERATOR_GAP_LIMIT + 1);
+    BOOST_CHECK(queried[0] == expected[0]);
+    BOOST_CHECK(queried[1] == expected[1]);
+
+    // The in-use key was consumed by the scan, not skipped: issuing below a
+    // demonstrably active index is what this exists to prevent.
+    BOOST_CHECK_EQUAL(ReadWatermarkRecord(*wallet)->next_index, 2U);
+    auto next{interface->getNewMasternodeOperatorKey({})};
+    BOOST_REQUIRE(next.status == MasternodeOperatorKeyStatus::SUCCESS);
+    BOOST_CHECK_EQUAL(next.key.path, "m/9'/1'/3'/3'/2");
+    BOOST_CHECK(next.key.public_key == expected[2]);
+}
+
+BOOST_AUTO_TEST_CASE(encrypted_wallets_lock_unlock)
+{
+    auto wallet{MakeWallet()};
+    SetupMnemonicWallet(*wallet);
+    BOOST_REQUIRE(wallet->EncryptWallet("passphrase"));
+    auto interface{MakeWalletInterface(wallet)};
+    BOOST_CHECK(interface->hasMasternodeOperatorKeySource());
+
+    auto locked{interface->getNewMasternodeOperatorKey({})};
+    BOOST_CHECK(locked.status == MasternodeOperatorKeyStatus::WALLET_LOCKED);
+    BOOST_CHECK(locked.key.secret_key.empty());
+
+    // No operator-key records exist until the first operation.
+    BOOST_REQUIRE(wallet->Unlock("passphrase"));
+    BOOST_CHECK(!ReadWatermarkRecord(*wallet).has_value());
+    BOOST_CHECK(!ReadLookaheadRecord(*wallet).has_value());
+
+    auto unlocked{interface->getNewMasternodeOperatorKey({})};
+    BOOST_REQUIRE(unlocked.status == MasternodeOperatorKeyStatus::SUCCESS);
+    BOOST_CHECK_EQUAL(HexStr(unlocked.key.secret_key), DASHSYNC_OPERATOR_SECRET);
+    BOOST_CHECK_EQUAL(ReadWatermarkRecord(*wallet)->next_index, 1U);
+
+    // A lock landing while the predicate runs (without cs_wallet held)
+    // must not durably burn an index it can no longer derive.
+    auto raced{interface->getNewMasternodeOperatorKey([&](const CBLSPublicKey&) {
+        BOOST_REQUIRE(wallet->Lock());
+        return false;
+    })};
+    BOOST_CHECK(raced.status == MasternodeOperatorKeyStatus::WALLET_LOCKED);
+    BOOST_CHECK(raced.key.secret_key.empty());
+    BOOST_CHECK_EQUAL(ReadWatermarkRecord(*wallet)->next_index, 1U);
+    BOOST_REQUIRE(wallet->Unlock("passphrase"));
+    auto after_race{interface->getNewMasternodeOperatorKey({})};
+    BOOST_REQUIRE(after_race.status == MasternodeOperatorKeyStatus::SUCCESS);
+    BOOST_CHECK_EQUAL(after_race.key.path, "m/9'/1'/3'/3'/1");
+
+    BOOST_REQUIRE(wallet->Lock());
+    BOOST_CHECK(interface->getMasternodeOperatorKey(unlocked.key.public_key).status ==
+                MasternodeOperatorKeyStatus::WALLET_LOCKED);
+}
+
+BOOST_AUTO_TEST_CASE(fresh_wallets_have_no_records_until_first_use)
+{
+    auto wallet{MakeWallet()};
+    SetupMnemonicWallet(*wallet);
+    auto interface{MakeWalletInterface(wallet)};
+    BOOST_CHECK(interface->hasMasternodeOperatorKeySource());
+    BOOST_CHECK(!ReadWatermarkRecord(*wallet).has_value());
+    BOOST_CHECK(!ReadLookaheadRecord(*wallet).has_value());
+
+    auto first{interface->getNewMasternodeOperatorKey({})};
+    BOOST_REQUIRE(first.status == MasternodeOperatorKeyStatus::SUCCESS);
+    BOOST_CHECK(ReadWatermarkRecord(*wallet).has_value());
+    BOOST_CHECK(ReadLookaheadRecord(*wallet).has_value());
+}
+
+BOOST_AUTO_TEST_CASE(database_write_failure_withholds_the_key)
+{
+    auto database{std::make_unique<ToggleFailDatabase>()};
+    auto* database_ptr{database.get()};
+    auto wallet{MakeWallet(std::move(database))};
+    SetupMnemonicWallet(*wallet);
+    auto interface{MakeWalletInterface(wallet)};
+    BOOST_REQUIRE(TopUpLookahead(*wallet) == MasternodeOperatorKeyStatus::SUCCESS);
+
+    // If the watermark cannot be persisted, no secret is returned and the
+    // index remains available.
+    database_ptr->write_success = false;
+    auto failed{interface->getNewMasternodeOperatorKey({})};
+    BOOST_CHECK(failed.status == MasternodeOperatorKeyStatus::DATABASE_ERROR);
+    BOOST_CHECK(failed.key.secret_key.empty());
+
+    // The sync hook must not mutate the in-memory watermark either when its
+    // write fails: index 0 must still be handed out below.
+    const auto expected{DashSyncPublicKeys(1)};
+    wallet->transactionAddedToMempool(BuildProRegTx(ParseBasic(expected[0]), /*legacy_encoding=*/true), GetTime());
+
+    database_ptr->write_success = true;
+    auto succeeded{interface->getNewMasternodeOperatorKey({})};
+    BOOST_REQUIRE(succeeded.status == MasternodeOperatorKeyStatus::SUCCESS);
+    BOOST_CHECK_EQUAL(succeeded.key.path, "m/9'/1'/3'/3'/0");
+    BOOST_CHECK(succeeded.key.public_key == expected[0]);
+}
+
+BOOST_AUTO_TEST_CASE(unsupported_sources_fail_closed)
+{
+    auto no_source{MakeWallet()};
+    auto no_source_interface{MakeWalletInterface(no_source)};
+    BOOST_CHECK(!no_source_interface->hasMasternodeOperatorKeySource());
+    BOOST_CHECK(no_source_interface->getNewMasternodeOperatorKey({}).status ==
+                MasternodeOperatorKeyStatus::NOT_SUPPORTED);
+
+    // Legacy wallets are unsupported even with a genuine mnemonic: operator
+    // keys are a descriptor-wallet feature.
+    auto legacy{MakeWallet()};
+    SetupLegacyMnemonicWallet(*legacy);
+    auto legacy_interface{MakeWalletInterface(legacy)};
+    BOOST_CHECK(!legacy_interface->hasMasternodeOperatorKeySource());
+    BOOST_CHECK(legacy_interface->getNewMasternodeOperatorKey({}).status == MasternodeOperatorKeyStatus::NOT_SUPPORTED);
+
+    auto descriptor_without_mnemonic{MakeWallet()};
+    {
+        std::array<unsigned char, 32> bytes{};
+        bytes.back() = 1;
+        CExtKey master;
+        master.SetSeed(MakeByteSpan(bytes));
+        LOCK(descriptor_without_mnemonic->cs_wallet);
+        descriptor_without_mnemonic->SetWalletFlag(WALLET_FLAG_DESCRIPTORS);
+        descriptor_without_mnemonic->SetupDescriptorScriptPubKeyMans(master, {}, {});
+    }
+    auto no_mnemonic_interface{MakeWalletInterface(descriptor_without_mnemonic)};
+    BOOST_CHECK(!no_mnemonic_interface->hasMasternodeOperatorKeySource());
+
+    auto ambiguous{MakeWallet()};
+    SetupMnemonicWallet(*ambiguous, DASHSYNC_MNEMONIC);
+    SetupMnemonicWallet(*ambiguous, SECOND_MNEMONIC);
+    auto ambiguous_interface{MakeWalletInterface(ambiguous)};
+    BOOST_CHECK(!ambiguous_interface->hasMasternodeOperatorKeySource());
+
+    for (const auto flag : {WALLET_FLAG_DISABLE_PRIVATE_KEYS, WALLET_FLAG_EXTERNAL_SIGNER}) {
+        auto restricted{MakeWallet()};
+        SetupMnemonicWallet(*restricted);
+        restricted->SetWalletFlag(flag);
+        auto restricted_interface{MakeWalletInterface(restricted)};
+        BOOST_CHECK(!restricted_interface->hasMasternodeOperatorKeySource());
+        BOOST_CHECK(restricted_interface->getNewMasternodeOperatorKey({}).status ==
+                    MasternodeOperatorKeyStatus::NOT_SUPPORTED);
+    }
+}
+
+BOOST_AUTO_TEST_CASE(named_database_persists_consumption_across_reload)
+{
+    const std::string name{"mn-operator"};
+    interfaces::MasternodeOperatorKey consumed;
+    {
+        auto wallet{MakeNamedWallet(name, /*existing=*/false)};
+        SetupMnemonicWallet(*wallet);
+        auto interface{MakeWalletInterface(wallet)};
+        auto result{interface->getNewMasternodeOperatorKey({})};
+        BOOST_REQUIRE(result.status == MasternodeOperatorKeyStatus::SUCCESS);
+        consumed = result.key;
+    }
+
+    auto reloaded{MakeNamedWallet(name, /*existing=*/true)};
+    auto interface{MakeWalletInterface(reloaded)};
+    BOOST_REQUIRE(interface->hasMasternodeOperatorKeySource());
+    auto recovered{interface->getMasternodeOperatorKey(consumed.public_key)};
+    BOOST_REQUIRE(recovered.status == MasternodeOperatorKeyStatus::SUCCESS);
+    BOOST_CHECK(recovered.key.secret_key == consumed.secret_key);
+    BOOST_CHECK_EQUAL(recovered.key.path, consumed.path);
+
+    auto next{interface->getNewMasternodeOperatorKey({})};
+    BOOST_REQUIRE(next.status == MasternodeOperatorKeyStatus::SUCCESS);
+    BOOST_CHECK_EQUAL(next.key.path, "m/9'/1'/3'/3'/1");
+}
+
+BOOST_AUTO_TEST_CASE(stale_and_malformed_records_are_ignored)
+{
+    // Structurally broken records must not fail the load, and well-formed
+    // records left behind by a different seed must not be trusted.
+    {
+        const std::string name{"mn-operator-malformed"};
+        {
+            auto wallet{MakeNamedWallet(name, /*existing=*/false)};
+            SetupMnemonicWallet(*wallet);
+            // Empty source id fails validation at load.
+            WalletBatch batch{wallet->GetDatabase()};
+            BOOST_REQUIRE(batch.WriteMasternodeOperatorWatermark({{}, 5}));
+            // Not a serialized lookahead at all.
+            std::unique_ptr<DatabaseBatch> raw{wallet->GetDatabase().MakeBatch()};
+            BOOST_REQUIRE(raw->Write(DBKeys::MASTERNODE_OPERATOR_LOOKAHEAD, uint8_t{7}));
+        }
+        auto reloaded{MakeNamedWallet(name, /*existing=*/true)};
+        auto interface{MakeWalletInterface(reloaded)};
+        auto result{interface->getNewMasternodeOperatorKey({})};
+        BOOST_REQUIRE(result.status == MasternodeOperatorKeyStatus::SUCCESS);
+        BOOST_CHECK_EQUAL(HexStr(result.key.secret_key), DASHSYNC_OPERATOR_SECRET);
+    }
+
+    {
+        const std::string name{"mn-operator-stale"};
+        const std::vector<unsigned char> foreign_source(21, 0xAA);
+        const std::vector<std::vector<unsigned char>> foreign_keys{RandomOperatorKeyBytes(), RandomOperatorKeyBytes()};
+        {
+            auto wallet{MakeNamedWallet(name, /*existing=*/false)};
+            SetupMnemonicWallet(*wallet);
+            WalletBatch batch{wallet->GetDatabase()};
+            BOOST_REQUIRE(batch.WriteMasternodeOperatorWatermark({foreign_source, 400}));
+            BOOST_REQUIRE(batch.WriteMasternodeOperatorLookahead({foreign_source, 0, foreign_keys}));
+        }
+        auto reloaded{MakeNamedWallet(name, /*existing=*/true)};
+        // A provider transaction matching the foreign lookahead must not
+        // advance anything: the lookahead does not belong to the active seed.
+        reloaded->transactionAddedToMempool(BuildProRegTx(ParseBasic(foreign_keys[0]), /*legacy_encoding=*/false),
+                                            GetTime());
+        BOOST_CHECK_EQUAL(ReadWatermarkRecord(*reloaded)->next_index, 400U);
+        BOOST_CHECK(ReadWatermarkRecord(*reloaded)->source_id == foreign_source);
+
+        // Issuance ignores the foreign watermark and starts at index 0.
+        auto interface{MakeWalletInterface(reloaded)};
+        auto result{interface->getNewMasternodeOperatorKey({})};
+        BOOST_REQUIRE(result.status == MasternodeOperatorKeyStatus::SUCCESS);
+        BOOST_CHECK_EQUAL(HexStr(result.key.secret_key), DASHSYNC_OPERATOR_SECRET);
+        BOOST_CHECK_EQUAL(result.key.path, "m/9'/1'/3'/3'/0");
+        // The foreign records were replaced by ones for the active seed.
+        BOOST_CHECK_EQUAL(ReadWatermarkRecord(*reloaded)->next_index, 1U);
+        BOOST_CHECK(ReadWatermarkRecord(*reloaded)->source_id != foreign_source);
+    }
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+} // namespace wallet
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
index 6a941af05ca2..98ec293ce611 100644
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -7,8 +7,10 @@
 #include <wallet/wallet.h>
 
 #include <blockfilter.h>
+#include <bls/bls.h>
 #include <chain.h>
 #include <chainparams.h>
+#include <evo/specialtx.h>
 #include <consensus/amount.h>
 #include <consensus/consensus.h>
 #include <crypto/common.h>
@@ -1410,6 +1412,11 @@ void CWallet::RecursiveUpdateTxState(const uint256& tx_hash, const TryUpdatingSt
 
 void CWallet::SyncTransaction(const CTransactionRef& ptx, const SyncTxState& state, WalletBatch& batch, bool update_tx, bool rescanning_old_block)
 {
+    // Runs for every synced transaction, not only "ours": a provider
+    // transaction assigning one of our derivable operator keys is how a
+    // restored wallet learns about consumed operator-key indexes.
+    MaybeAdvanceMasternodeOperatorWatermark(*ptx, batch);
+
     if (!AddToWalletIfInvolvingMe(ptx, state, batch, update_tx, rescanning_old_block))
         return; // Not one of ours
 
@@ -3161,6 +3168,7 @@ std::shared_ptr<CWallet> CWallet::Create(WalletContext& context, const std::stri
     const bool fFirstRun = walletInstance->m_spk_managers.empty() &&
                      !walletInstance->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS) &&
                      !walletInstance->IsWalletFlagSet(WALLET_FLAG_BLANK_WALLET);
+    bool restored_from_user_mnemonic{false};
     if (fFirstRun)
     {
         walletInstance->SetMinVersion(FEATURE_LATEST);
@@ -3209,6 +3217,7 @@ std::shared_ptr<CWallet> CWallet::Create(WalletContext& context, const std::stri
 
                     mnemonic = args.GetArg("-mnemonic", "");
                     mnemonic_passphrase = args.GetArg("-mnemonicpassphrase", "");
+                    restored_from_user_mnemonic = !mnemonic.empty();
                     LOCK(walletInstance->cs_wallet);
                     if (auto spk_man = walletInstance->GetLegacyScriptPubKeyMan()) {
                         spk_man->GenerateNewHDChain(mnemonic, mnemonic_passphrase);
@@ -3228,6 +3237,7 @@ std::shared_ptr<CWallet> CWallet::Create(WalletContext& context, const std::stri
                 mnemonic_passphrase.reserve(256);
                 mnemonic = args.GetArg("-mnemonic", "");
                 mnemonic_passphrase = args.GetArg("-mnemonicpassphrase", "");
+                restored_from_user_mnemonic |= !mnemonic.empty();
                 args.ForceRemoveArg("mnemonic");
                 args.ForceRemoveArg("mnemonicpassphrase");
                 walletInstance->SetupDescriptorScriptPubKeyMans(mnemonic, mnemonic_passphrase);
@@ -3403,6 +3413,15 @@ std::shared_ptr<CWallet> CWallet::Create(WalletContext& context, const std::stri
     // Try to top up keypool. No-op if the wallet is locked.
     walletInstance->TopUpKeyPool();
 
+    // A user-supplied mnemonic is a restore: provider transactions assigning
+    // its derived operator keys may already exist in history, so build the
+    // recognition lookahead before AttachChain can rescan. Recognition is
+    // best-effort by design; a freshly generated seed cannot appear in
+    // history, so no lookahead is needed until the feature is first used.
+    if (restored_from_user_mnemonic) {
+        WITH_LOCK(walletInstance->cs_wallet, walletInstance->TopUpMasternodeOperatorLookahead());
+    }
+
     NotifyWalletLoading(context, walletInstance);
 
     if (chain && !AttachChain(walletInstance, *chain, rescan_required, error, warnings)) {
@@ -3822,6 +3841,363 @@ std::vector<const Governance::Object*> CWallet::GetGovernanceObjects()
     return vecObjects;
 }
 
+static uint32_t MasternodeOperatorCoinType()
+{
+    // 5 on mainnet, 1 everywhere else - the DashSync convention of using
+    // testnet's coin type for every non-mainnet network.
+    return static_cast<uint32_t>(Params().ExtCoinType());
+}
+
+static std::vector<unsigned char> CanonicalOperatorKeyBytes(const CBLSPublicKey& public_key)
+{
+    return public_key.ToByteVector(/*specificLegacyScheme=*/false);
+}
+
+bool CWallet::LoadMasternodeOperatorWatermark(const MasternodeOperatorWatermark& watermark)
+{
+    AssertLockHeld(cs_wallet);
+    if (watermark.source_id.empty() || watermark.next_index > MASTERNODE_OPERATOR_MAX_INDEX) return false;
+    m_mn_operator_watermark = watermark;
+    return true;
+}
+
+bool CWallet::LoadMasternodeOperatorLookahead(const MasternodeOperatorLookahead& lookahead)
+{
+    AssertLockHeld(cs_wallet);
+    if (lookahead.source_id.empty() || lookahead.public_keys.empty() ||
+        lookahead.public_keys.size() > MASTERNODE_OPERATOR_GAP_LIMIT ||
+        lookahead.base_index > MASTERNODE_OPERATOR_MAX_INDEX - lookahead.public_keys.size()) {
+        return false;
+    }
+    for (const auto& public_key : lookahead.public_keys) {
+        CBLSPublicKey parsed;
+        parsed.SetBytes(public_key, /*specificLegacyScheme=*/false);
+        if (!parsed.IsValid() || CanonicalOperatorKeyBytes(parsed) != public_key) return false;
+    }
+    m_mn_operator_lookahead = lookahead;
+    return true;
+}
+
+ScriptPubKeyMan* CWallet::GetMasternodeOperatorKeySource(std::vector<unsigned char>* source_id_out) const
+{
+    AssertLockHeld(cs_wallet);
+    if (IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS) || IsWalletFlagSet(WALLET_FLAG_EXTERNAL_SIGNER)) {
+        return nullptr;
+    }
+
+    ScriptPubKeyMan* source{nullptr};
+    std::optional<std::vector<unsigned char>> source_id;
+    for (const auto& [id, spk_man] : m_spk_managers) {
+        std::vector<unsigned char> candidate;
+        const auto status{spk_man->GetMasternodeOperatorKeySource(candidate)};
+        if (status == MasternodeOperatorKeySourceStatus::AMBIGUOUS) return nullptr;
+        if (status == MasternodeOperatorKeySourceStatus::NONE) continue;
+        if (!source_id) source_id = candidate;
+        if (*source_id != candidate) return nullptr;
+        if (!source) source = spk_man.get();
+    }
+    if (source && source_id_out) *source_id_out = std::move(*source_id);
+    return source;
+}
+
+bool CWallet::HasMasternodeOperatorKeySource() const
+{
+    LOCK(cs_wallet);
+    return GetMasternodeOperatorKeySource() != nullptr;
+}
+
+uint32_t CWallet::GetMasternodeOperatorNextIndex(const std::vector<unsigned char>& source_id) const
+{
+    AssertLockHeld(cs_wallet);
+    if (!m_mn_operator_watermark || m_mn_operator_watermark->source_id != source_id) return 0;
+    return m_mn_operator_watermark->next_index;
+}
+
+bool CWallet::RaiseMasternodeOperatorWatermark(const std::vector<unsigned char>& source_id, uint32_t next_index,
+                                               WalletBatch& batch)
+{
+    AssertLockHeld(cs_wallet);
+    if (next_index <= GetMasternodeOperatorNextIndex(source_id)) return true;
+    const MasternodeOperatorWatermark updated{source_id, next_index};
+    if (!batch.WriteMasternodeOperatorWatermark(updated)) return false;
+    m_mn_operator_watermark = updated;
+    return true;
+}
+
+MasternodeOperatorKeyStatus CWallet::TopUpMasternodeOperatorLookahead()
+{
+    AssertLockHeld(cs_wallet);
+    std::vector<unsigned char> source_id;
+    ScriptPubKeyMan* source{GetMasternodeOperatorKeySource(&source_id)};
+    if (!source) return MasternodeOperatorKeyStatus::NOT_SUPPORTED;
+    if (IsLocked()) return MasternodeOperatorKeyStatus::WALLET_LOCKED;
+
+    const uint32_t next{GetMasternodeOperatorNextIndex(source_id)};
+    const uint32_t end{std::min<uint32_t>(next + MASTERNODE_OPERATOR_GAP_LIMIT, MASTERNODE_OPERATOR_MAX_INDEX)};
+    if (next >= end) return MasternodeOperatorKeyStatus::EXHAUSTED;
+    if (m_mn_operator_lookahead && m_mn_operator_lookahead->source_id == source_id &&
+        m_mn_operator_lookahead->base_index == next && m_mn_operator_lookahead->public_keys.size() == end - next) {
+        return MasternodeOperatorKeyStatus::SUCCESS;
+    }
+
+    MasternodeOperatorLookahead lookahead{source_id, next, {}};
+    lookahead.public_keys.reserve(end - next);
+    const auto status{source->DeriveMasternodeOperatorKeys(MasternodeOperatorCoinType(), next, end,
+                                                           [&lookahead](uint32_t, const CBLSSecretKey& secret) {
+                                                               lookahead.public_keys.push_back(
+                                                                   CanonicalOperatorKeyBytes(secret.GetPublicKey()));
+                                                               return true;
+                                                           })};
+    if (status != MasternodeOperatorKeyStatus::SUCCESS) return status;
+    if (lookahead.public_keys.size() != end - next) return MasternodeOperatorKeyStatus::DERIVATION_ERROR;
+    if (!WalletBatch(GetDatabase()).WriteMasternodeOperatorLookahead(lookahead)) {
+        return MasternodeOperatorKeyStatus::DATABASE_ERROR;
+    }
+    m_mn_operator_lookahead = std::move(lookahead);
+    return MasternodeOperatorKeyStatus::SUCCESS;
+}
+
+void CWallet::MaybeAdvanceMasternodeOperatorWatermark(const CTransaction& tx, WalletBatch& batch)
+{
+    AssertLockHeld(cs_wallet);
+    if (tx.nType != TRANSACTION_PROVIDER_REGISTER && tx.nType != TRANSACTION_PROVIDER_UPDATE_REGISTRAR) return;
+    // Without a lookahead nothing can be matched; recognition is best-effort
+    // by design, so nothing is tracked for later either.
+    if (!m_mn_operator_lookahead) return;
+
+    CBLSPublicKey public_key;
+    if (tx.nType == TRANSACTION_PROVIDER_REGISTER) {
+        const auto payload{GetTxPayload<CProRegTx>(tx)};
+        if (!payload) return;
+        public_key = payload->pubKeyOperator.Get();
+    } else {
+        const auto payload{GetTxPayload<CProUpRegTx>(tx)};
+        if (!payload) return;
+        public_key = payload->pubKeyOperator.Get();
+    }
+    if (!public_key.IsValid()) return;
+
+    // Canonical bytes make this a key-value comparison: a legacy-scheme wire
+    // encoding of a lookahead key cannot cause a miss.
+    const auto target{CanonicalOperatorKeyBytes(public_key)};
+    const auto& keys{m_mn_operator_lookahead->public_keys};
+    const auto it{std::find(keys.begin(), keys.end(), target)};
+    if (it == keys.end()) return;
+    const uint32_t index{m_mn_operator_lookahead->base_index + static_cast<uint32_t>(it - keys.begin())};
+
+    // Only trust a lookahead that belongs to the active seed.
+    std::vector<unsigned char> source_id;
+    ScriptPubKeyMan* source{GetMasternodeOperatorKeySource(&source_id)};
+    if (!source || source_id != m_mn_operator_lookahead->source_id) {
+        return;
+    }
+    if (index < GetMasternodeOperatorNextIndex(source_id)) return; // already consumed
+
+    // The write lands before the in-memory watermark moves; a failed write is
+    // retried the next time a transaction with this key is synced.
+    if (!RaiseMasternodeOperatorWatermark(source_id, index + 1, batch)) {
+        WalletLogPrintf("Failed to persist masternode operator watermark for index %u\n", index);
+        return;
+    }
+    WalletLogPrintf("Masternode operator key index %u seen in provider transaction %s; watermark advanced to %u\n",
+                    index, tx.GetHash().ToString(), index + 1);
+}
+
+interfaces::MasternodeOperatorKeyResult CWallet::GetNewMasternodeOperatorKey(
+    const std::function<bool(const CBLSPublicKey&)>& is_in_use)
+{
+    interfaces::MasternodeOperatorKeyResult result;
+    const uint32_t coin_type{MasternodeOperatorCoinType()};
+
+    uint32_t candidate{0};
+    {
+        LOCK(cs_wallet);
+        std::vector<unsigned char> source_id;
+        ScriptPubKeyMan* source{GetMasternodeOperatorKeySource(&source_id)};
+        if (!source) {
+            result.status = MasternodeOperatorKeyStatus::NOT_SUPPORTED;
+            return result;
+        }
+        if (IsLocked()) {
+            result.status = MasternodeOperatorKeyStatus::WALLET_LOCKED;
+            return result;
+        }
+        candidate = GetMasternodeOperatorNextIndex(source_id);
+    }
+
+    if (is_in_use) {
+        // Gap-limit scan: consult the caller's predicate (typically the
+        // current masternode list) from the watermark upward and issue only
+        // above every index it reports in use, so a restored wallet cannot
+        // re-issue a key that is demonstrably active. The predicate is
+        // queried without cs_wallet held because it may read node chainstate.
+        uint32_t scan_index{candidate};
+        uint32_t consecutive_misses{0};
+        while (consecutive_misses < MASTERNODE_OPERATOR_GAP_LIMIT) {
+            if (scan_index >= MASTERNODE_OPERATOR_MAX_INDEX) {
+                result.status = MasternodeOperatorKeyStatus::EXHAUSTED;
+                return result;
+            }
+            const uint32_t chunk_end{
+                std::min(scan_index + MASTERNODE_OPERATOR_GAP_LIMIT, MASTERNODE_OPERATOR_MAX_INDEX)};
+            std::vector<CBLSPublicKey> chunk;
+            chunk.reserve(chunk_end - scan_index);
+            {
+                LOCK(cs_wallet);
+                ScriptPubKeyMan* source{GetMasternodeOperatorKeySource()};
+                if (!source) {
+                    result.status = MasternodeOperatorKeyStatus::NOT_SUPPORTED;
+                    return result;
+                }
+                const auto status{source->DeriveMasternodeOperatorKeys(
+                    coin_type, scan_index, chunk_end, [&chunk](uint32_t, const CBLSSecretKey& secret) {
+                        chunk.push_back(secret.GetPublicKey());
+                        return true;
+                    })};
+                if (status != MasternodeOperatorKeyStatus::SUCCESS) {
+                    result.status = status;
+                    return result;
+                }
+            }
+            for (uint32_t offset{0}; offset < chunk.size() && consecutive_misses < MASTERNODE_OPERATOR_GAP_LIMIT;
+                 ++offset) {
+                if (is_in_use(chunk[offset])) {
+                    candidate = scan_index + offset + 1;
+                    consecutive_misses = 0;
+                } else {
+                    ++consecutive_misses;
+                }
+            }
+            scan_index = chunk_end;
+        }
+    }
+
+    LOCK(cs_wallet);
+    std::vector<unsigned char> source_id;
+    ScriptPubKeyMan* source{GetMasternodeOperatorKeySource(&source_id)};
+    if (!source) {
+        result.status = MasternodeOperatorKeyStatus::NOT_SUPPORTED;
+        return result;
+    }
+    // The wallet may have been locked while the predicate ran without
+    // cs_wallet; nothing has been consumed yet, so fail without burning an
+    // index the seed can no longer derive.
+    if (IsLocked()) {
+        result.status = MasternodeOperatorKeyStatus::WALLET_LOCKED;
+        return result;
+    }
+    // The sync hook may have advanced the watermark while the predicate ran;
+    // never issue below it. A candidate raised this way skips a fresh
+    // predicate query, matching the accepted race with concurrent
+    // registrations (consensus rejects a genuine duplicate).
+    candidate = std::max(candidate, GetMasternodeOperatorNextIndex(source_id));
+    if (candidate >= MASTERNODE_OPERATOR_MAX_INDEX) {
+        result.status = MasternodeOperatorKeyStatus::EXHAUSTED;
+        return result;
+    }
+
+    CBLSSecretKey secret;
+    const auto status{source->DeriveMasternodeOperatorKey(coin_type, candidate, secret)};
+    if (status != MasternodeOperatorKeyStatus::SUCCESS) {
+        result.status = status;
+        return result;
+    }
+
+    // The watermark is recorded before the secret is ever returned;
+    // consumption is permanent and never rolled back.
+    WalletBatch batch(GetDatabase());
+    if (!RaiseMasternodeOperatorWatermark(source_id, candidate + 1, batch)) {
+        secret.Reset();
+        result.status = MasternodeOperatorKeyStatus::DATABASE_ERROR;
+        return result;
+    }
+    // Keep the recognition lookahead ahead of the new watermark; a failure
+    // only degrades opportunistic recognition, never the issued key.
+    if (const auto lookahead_status{TopUpMasternodeOperatorLookahead()};
+        lookahead_status != MasternodeOperatorKeyStatus::SUCCESS) {
+        WalletLogPrintf("Failed to refresh masternode operator lookahead (status %d)\n",
+                        static_cast<int>(lookahead_status));
+    }
+
+    result.key.secret_key.resize(CBLSSecretKey::SerSize);
+    if (!secret.SerializeTo(result.key.secret_key)) {
+        secret.Reset();
+        result.key.secret_key.clear();
+        result.status = MasternodeOperatorKeyStatus::DERIVATION_ERROR;
+        return result;
+    }
+    result.key.public_key = CanonicalOperatorKeyBytes(secret.GetPublicKey());
+    secret.Reset();
+    result.key.path = MasternodeOperatorKeyPath(coin_type, candidate);
+    result.status = MasternodeOperatorKeyStatus::SUCCESS;
+    return result;
+}
+
+interfaces::MasternodeOperatorKeyResult CWallet::GetMasternodeOperatorKey(const CBLSPublicKey& public_key)
+{
+    interfaces::MasternodeOperatorKeyResult result;
+    if (!public_key.IsValid()) {
+        result.status = MasternodeOperatorKeyStatus::INVALID_KEY;
+        return result;
+    }
+
+    LOCK(cs_wallet);
+    std::vector<unsigned char> source_id;
+    ScriptPubKeyMan* source{GetMasternodeOperatorKeySource(&source_id)};
+    if (!source) {
+        result.status = MasternodeOperatorKeyStatus::NOT_SUPPORTED;
+        return result;
+    }
+    if (IsLocked()) {
+        result.status = MasternodeOperatorKeyStatus::WALLET_LOCKED;
+        return result;
+    }
+    // Only consumed indexes - those below the watermark - are addressable:
+    // exposure equals consumption, and nothing above the watermark has been
+    // exposed.
+    const uint32_t next{GetMasternodeOperatorNextIndex(source_id)};
+    if (next == 0) {
+        result.status = MasternodeOperatorKeyStatus::NOT_FOUND;
+        return result;
+    }
+
+    const uint32_t coin_type{MasternodeOperatorCoinType()};
+    const auto target{CanonicalOperatorKeyBytes(public_key)};
+    CBLSSecretKey found;
+    uint32_t found_index{0};
+    const auto status{source->DeriveMasternodeOperatorKeys(coin_type, 0, next,
+                                                           [&](uint32_t index, const CBLSSecretKey& secret) {
+                                                               if (CanonicalOperatorKeyBytes(secret.GetPublicKey()) !=
+                                                                   target) {
+                                                                   return true;
+                                                               }
+                                                               found = secret;
+                                                               found_index = index;
+                                                               return false;
+                                                           })};
+    if (status != MasternodeOperatorKeyStatus::SUCCESS) {
+        result.status = status;
+        return result;
+    }
+    if (!found.IsValid()) {
+        result.status = MasternodeOperatorKeyStatus::NOT_FOUND;
+        return result;
+    }
+
+    result.key.secret_key.resize(CBLSSecretKey::SerSize);
+    if (!found.SerializeTo(result.key.secret_key)) {
+        found.Reset();
+        result.key.secret_key.clear();
+        result.status = MasternodeOperatorKeyStatus::DERIVATION_ERROR;
+        return result;
+    }
+    found.Reset();
+    result.key.public_key = target;
+    result.key.path = MasternodeOperatorKeyPath(coin_type, found_index);
+    result.status = MasternodeOperatorKeyStatus::SUCCESS;
+    return result;
+}
+
 CKeyPool::CKeyPool()
 {
     nTime = GetTime();
diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h
index 059e7712c6c4..d34ac716ab45 100644
--- a/src/wallet/wallet.h
+++ b/src/wallet/wallet.h
@@ -28,6 +28,7 @@
 #include <wallet/crypter.h>
 #include <wallet/coinselection.h>
 #include <external_signer.h>
+#include <wallet/masternode_operator.h>
 #include <wallet/scriptpubkeyman.h>
 #include <wallet/transaction.h>
 #include <wallet/walletdb.h>
@@ -49,6 +50,7 @@
 
 #include <boost/signals2/signal.hpp>
 
+class CBLSPublicKey;
 class CKey;
 class CScript;
 class CTxDSIn;
@@ -426,6 +428,35 @@ class CWallet final : public WalletStorage, public interfaces::Chain::Notificati
     //! Whether the CoinJoin client is mixing with this wallet
     std::atomic<bool> m_mixing{false};
 
+    /** Operator-key consumption watermark: indexes below next_index are
+     *  permanently consumed. Advisory; ignored unless its source id matches
+     *  the active seed. */
+    std::optional<MasternodeOperatorWatermark> m_mn_operator_watermark GUARDED_BY(cs_wallet);
+    /** Advisory lookahead of derived operator public keys at and above the
+     *  watermark, used to opportunistically recognize provider transactions
+     *  during sync - including while the wallet is locked. */
+    std::optional<MasternodeOperatorLookahead> m_mn_operator_lookahead GUARDED_BY(cs_wallet);
+
+    /** The ScriptPubKeyMan holding this wallet's single genuine mnemonic
+     *  source, or nullptr when operator-key derivation is unsupported. Also
+     *  returns the source identifier when source_id is provided. */
+    ScriptPubKeyMan* GetMasternodeOperatorKeySource(std::vector<unsigned char>* source_id = nullptr) const
+        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
+    /** The watermark for the given seed source; 0 when absent or belonging to
+     *  a different seed. */
+    uint32_t GetMasternodeOperatorNextIndex(const std::vector<unsigned char>& source_id) const
+        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
+    /** Durably raise the watermark to next_index (never lowers it). The write
+     *  happens before the in-memory value moves, so a failure leaves memory
+     *  and disk agreeing. */
+    bool RaiseMasternodeOperatorWatermark(const std::vector<unsigned char>& source_id, uint32_t next_index,
+                                          WalletBatch& batch) EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
+    /** Advance the watermark past a lookahead key assigned by a provider
+     *  transaction seen on the transaction-sync path. Best-effort recognition:
+     *  a missing or stale lookahead simply means no match. */
+    void MaybeAdvanceMasternodeOperatorWatermark(const CTransaction& tx, WalletBatch& batch)
+        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
+
     /** Height of last block processed is used by wallet to know depth of transactions
      * without relying on Chain interface beyond asynchronous updates. For safety, we
      * initialize it to -1. Height is a pointer on node's tip and doesn't imply
@@ -1003,6 +1034,31 @@ class CWallet final : public WalletStorage, public interfaces::Chain::Notificati
     /** Returns a vector containing pointers to the governance objects in m_gobjects */
     std::vector<const Governance::Object*> GetGovernanceObjects() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
 
+    /** Load the operator-key watermark/lookahead records. Return false for
+     *  unusable records, which are advisory and must not fail the wallet load. */
+    bool LoadMasternodeOperatorWatermark(const MasternodeOperatorWatermark& watermark)
+        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
+    bool LoadMasternodeOperatorLookahead(const MasternodeOperatorLookahead& lookahead)
+        EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
+    /** Whether deterministic operator-key operations are supported. */
+    bool HasMasternodeOperatorKeySource() const;
+    /** Derive and persist the recognition lookahead covering the gap limit
+     *  above the watermark, so the transaction-sync path can match provider
+     *  transactions without the seed. No-op when already current; requires
+     *  the seed (fails on locked or unsupported wallets). */
+    MasternodeOperatorKeyStatus TopUpMasternodeOperatorLookahead() EXCLUSIVE_LOCKS_REQUIRED(cs_wallet);
+    /** Derive and permanently consume the lowest operator-key index at or
+     *  above the watermark that is not in use. The watermark is persisted
+     *  before the secret is returned and never rolled back. is_in_use may be
+     *  empty; when set it is consulted without cs_wallet held so the caller
+     *  can query node chainstate, and issuance skips past every index it
+     *  reports in use (gap-limit scan). */
+    interfaces::MasternodeOperatorKeyResult GetNewMasternodeOperatorKey(
+        const std::function<bool(const CBLSPublicKey&)>& is_in_use);
+    /** Re-derive a previously consumed operator key (an index below the
+     *  watermark) by its public key. Read-only. */
+    interfaces::MasternodeOperatorKeyResult GetMasternodeOperatorKey(const CBLSPublicKey& public_key);
+
     /**
      * Blocks until the wallet state is up-to-date to /at least/ the current
      * chain at the time this function is entered
diff --git a/src/wallet/walletdb.cpp b/src/wallet/walletdb.cpp
index 4b82c166a345..da7a26bb9d6e 100644
--- a/src/wallet/walletdb.cpp
+++ b/src/wallet/walletdb.cpp
@@ -51,6 +51,8 @@ const std::string KEYMETA{"keymeta"};
 const std::string KEY{"key"};
 const std::string LOCKED_UTXO{"lockedutxo"};
 const std::string MASTER_KEY{"mkey"};
+const std::string MASTERNODE_OPERATOR_LOOKAHEAD{"mnoplook"};
+const std::string MASTERNODE_OPERATOR_NEXT{"mnopnext"};
 const std::string MINVERSION{"minversion"};
 const std::string NAME{"name"};
 const std::string OLD_KEY{"wkey"};
@@ -242,6 +244,26 @@ bool WalletBatch::WriteCoinJoinPendingObs(const std::map<COutPoint, int64_t>& pe
     return WriteIC(DBKeys::COINJOIN_PENDING_OBS, pending_obs);
 }
 
+bool WalletBatch::WriteMasternodeOperatorWatermark(const MasternodeOperatorWatermark& watermark)
+{
+    return WriteIC(DBKeys::MASTERNODE_OPERATOR_NEXT, watermark);
+}
+
+bool WalletBatch::ReadMasternodeOperatorWatermark(MasternodeOperatorWatermark& watermark)
+{
+    return m_batch->Read(DBKeys::MASTERNODE_OPERATOR_NEXT, watermark);
+}
+
+bool WalletBatch::WriteMasternodeOperatorLookahead(const MasternodeOperatorLookahead& lookahead)
+{
+    return WriteIC(DBKeys::MASTERNODE_OPERATOR_LOOKAHEAD, lookahead);
+}
+
+bool WalletBatch::ReadMasternodeOperatorLookahead(MasternodeOperatorLookahead& lookahead)
+{
+    return m_batch->Read(DBKeys::MASTERNODE_OPERATOR_LOOKAHEAD, lookahead);
+}
+
 bool WalletBatch::WriteGovernanceObject(const Governance::Object& obj)
 {
     return WriteIC(std::make_pair(DBKeys::G_OBJECT, obj.GetHash()), obj, false);
@@ -794,6 +816,29 @@ ReadKeyValue(CWallet* pwallet, CDataStream& ssKey, CDataStream& ssValue,
                 wss.crypted_mnemonics.insert(std::make_pair(std::make_pair(desc_id, pubkey.GetID()), std::make_pair(mnemonic, mnemonic_passphrase)));
             }
 
+        } else if (strType == DBKeys::MASTERNODE_OPERATOR_NEXT) {
+            // These records are advisory: they hold no secret and are rebuilt
+            // or ignored based on the active seed, so a malformed record is
+            // dropped from memory rather than failing the load.
+            try {
+                MasternodeOperatorWatermark watermark;
+                ssValue >> watermark;
+                if (!pwallet->LoadMasternodeOperatorWatermark(watermark)) {
+                    pwallet->WalletLogPrintf("Ignoring unusable masternode operator watermark record\n");
+                }
+            } catch (const std::exception&) {
+                pwallet->WalletLogPrintf("Ignoring malformed masternode operator watermark record\n");
+            }
+        } else if (strType == DBKeys::MASTERNODE_OPERATOR_LOOKAHEAD) {
+            try {
+                MasternodeOperatorLookahead lookahead;
+                ssValue >> lookahead;
+                if (!pwallet->LoadMasternodeOperatorLookahead(lookahead)) {
+                    pwallet->WalletLogPrintf("Ignoring unusable masternode operator lookahead record\n");
+                }
+            } catch (const std::exception&) {
+                pwallet->WalletLogPrintf("Ignoring malformed masternode operator lookahead record\n");
+            }
         } else if (strType == DBKeys::LOCKED_UTXO) {
             uint256 hash;
             uint32_t n;
diff --git a/src/wallet/walletdb.h b/src/wallet/walletdb.h
index 30c6aebdca30..251ca8330826 100644
--- a/src/wallet/walletdb.h
+++ b/src/wallet/walletdb.h
@@ -32,6 +32,8 @@ class CKeyPool;
 class CMasterKey;
 class CWallet;
 class CWalletTx;
+struct MasternodeOperatorLookahead;
+struct MasternodeOperatorWatermark;
 struct WalletContext;
 
 /**
@@ -83,6 +85,8 @@ extern const std::string KEY;
 extern const std::string KEYMETA;
 extern const std::string LOCKED_UTXO;
 extern const std::string MASTER_KEY;
+extern const std::string MASTERNODE_OPERATOR_LOOKAHEAD;
+extern const std::string MASTERNODE_OPERATOR_NEXT;
 extern const std::string MINVERSION;
 extern const std::string NAME;
 extern const std::string OLD_KEY;
@@ -227,6 +231,13 @@ class WalletBatch
     bool ReadCoinJoinPendingObs(std::map<COutPoint, int64_t>& pending_obs);
     bool WriteCoinJoinPendingObs(const std::map<COutPoint, int64_t>& pending_obs);
 
+    /** Operator-key consumption watermark and recognition lookahead. Both are
+     *  advisory and hold no secret: the BIP39 seed reproduces every key. */
+    bool WriteMasternodeOperatorWatermark(const MasternodeOperatorWatermark& watermark);
+    bool ReadMasternodeOperatorWatermark(MasternodeOperatorWatermark& watermark);
+    bool WriteMasternodeOperatorLookahead(const MasternodeOperatorLookahead& lookahead);
+    bool ReadMasternodeOperatorLookahead(MasternodeOperatorLookahead& lookahead);
+
     /** Write a CGovernanceObject to the database */
     bool WriteGovernanceObject(const Governance::Object& obj);
 
diff --git a/test/util/data/non-backported.txt b/test/util/data/non-backported.txt
index 84d49954a6a0..045d707ce629 100644
--- a/test/util/data/non-backported.txt
+++ b/test/util/data/non-backported.txt
@@ -28,6 +28,7 @@ src/index/timestamp*.h
 src/interfaces/providertx.h
 src/instantsend/*.cpp
 src/instantsend/*.h
+src/interfaces/masternode_operator.h
 src/llmq/*.cpp
 src/llmq/*.h
 src/masternode/*.cpp
@@ -85,4 +86,6 @@ src/util/wpipe.*
 src/wallet/bip39*
 src/wallet/coinjoin.*
 src/wallet/hdchain.*
+src/wallet/masternode_operator.*
+src/wallet/test/masternode_operator_tests.cpp
 src/hash_x11.h

From 84f670018a2f3eb5381e0988e46fb5a35bc0ff9e Mon Sep 17 00:00:00 2001
From: pasta <pasta@dashboost.org>
Date: Tue, 18 Aug 2026 12:45:22 -0500
Subject: [PATCH 3/6] refactor(wallet): isolate masternode operator
 implementation

---
 src/Makefile.am                   |   1 +
 src/wallet/mnoperator.cpp         | 381 ++++++++++++++++++++++++++++++
 src/wallet/wallet.cpp             | 359 ----------------------------
 test/util/data/non-backported.txt |   1 +
 4 files changed, 383 insertions(+), 359 deletions(-)
 create mode 100644 src/wallet/mnoperator.cpp

diff --git a/src/Makefile.am b/src/Makefile.am
index 132e6c7e34b5..5e57465859c1 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -711,6 +711,7 @@ libbitcoin_wallet_a_SOURCES = \
   wallet/hdchain.cpp \
   wallet/interfaces.cpp \
   wallet/load.cpp \
+  wallet/mnoperator.cpp \
   wallet/receive.cpp \
   wallet/rpc/addresses.cpp \
   wallet/rpc/backup.cpp \
diff --git a/src/wallet/mnoperator.cpp b/src/wallet/mnoperator.cpp
new file mode 100644
index 000000000000..945270ced958
--- /dev/null
+++ b/src/wallet/mnoperator.cpp
@@ -0,0 +1,381 @@
+// Copyright (c) 2026 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <wallet/wallet.h>
+
+#include <bls/bls.h>
+#include <chainparams.h>
+#include <evo/providertx.h>
+#include <evo/specialtx.h>
+
+#include <algorithm>
+#include <optional>
+#include <utility>
+#include <vector>
+
+namespace wallet {
+namespace {
+
+uint32_t MasternodeOperatorCoinType()
+{
+    // 5 on mainnet, 1 everywhere else - the DashSync convention of using
+    // testnet's coin type for every non-mainnet network.
+    return static_cast<uint32_t>(Params().ExtCoinType());
+}
+
+std::vector<unsigned char> CanonicalOperatorKeyBytes(const CBLSPublicKey& public_key)
+{
+    return public_key.ToByteVector(/*specificLegacyScheme=*/false);
+}
+
+} // namespace
+
+bool CWallet::LoadMasternodeOperatorWatermark(const MasternodeOperatorWatermark& watermark)
+{
+    AssertLockHeld(cs_wallet);
+    if (watermark.source_id.empty() || watermark.next_index > MASTERNODE_OPERATOR_MAX_INDEX) return false;
+    m_mn_operator_watermark = watermark;
+    return true;
+}
+
+bool CWallet::LoadMasternodeOperatorLookahead(const MasternodeOperatorLookahead& lookahead)
+{
+    AssertLockHeld(cs_wallet);
+    if (lookahead.source_id.empty() || lookahead.public_keys.empty() ||
+        lookahead.public_keys.size() > MASTERNODE_OPERATOR_GAP_LIMIT ||
+        lookahead.base_index > MASTERNODE_OPERATOR_MAX_INDEX - lookahead.public_keys.size()) {
+        return false;
+    }
+    for (const auto& public_key : lookahead.public_keys) {
+        CBLSPublicKey parsed;
+        parsed.SetBytes(public_key, /*specificLegacyScheme=*/false);
+        if (!parsed.IsValid() || CanonicalOperatorKeyBytes(parsed) != public_key) return false;
+    }
+    m_mn_operator_lookahead = lookahead;
+    return true;
+}
+
+ScriptPubKeyMan* CWallet::GetMasternodeOperatorKeySource(std::vector<unsigned char>* source_id_out) const
+{
+    AssertLockHeld(cs_wallet);
+    if (IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS) || IsWalletFlagSet(WALLET_FLAG_EXTERNAL_SIGNER)) {
+        return nullptr;
+    }
+
+    ScriptPubKeyMan* source{nullptr};
+    std::optional<std::vector<unsigned char>> source_id;
+    for (const auto& [id, spk_man] : m_spk_managers) {
+        std::vector<unsigned char> candidate;
+        const auto status{spk_man->GetMasternodeOperatorKeySource(candidate)};
+        if (status == MasternodeOperatorKeySourceStatus::AMBIGUOUS) return nullptr;
+        if (status == MasternodeOperatorKeySourceStatus::NONE) continue;
+        if (!source_id) source_id = candidate;
+        if (*source_id != candidate) return nullptr;
+        if (!source) source = spk_man.get();
+    }
+    if (source && source_id_out) *source_id_out = std::move(*source_id);
+    return source;
+}
+
+bool CWallet::HasMasternodeOperatorKeySource() const
+{
+    LOCK(cs_wallet);
+    return GetMasternodeOperatorKeySource() != nullptr;
+}
+
+uint32_t CWallet::GetMasternodeOperatorNextIndex(const std::vector<unsigned char>& source_id) const
+{
+    AssertLockHeld(cs_wallet);
+    if (!m_mn_operator_watermark || m_mn_operator_watermark->source_id != source_id) return 0;
+    return m_mn_operator_watermark->next_index;
+}
+
+bool CWallet::RaiseMasternodeOperatorWatermark(const std::vector<unsigned char>& source_id, uint32_t next_index,
+                                               WalletBatch& batch)
+{
+    AssertLockHeld(cs_wallet);
+    if (next_index <= GetMasternodeOperatorNextIndex(source_id)) return true;
+    const MasternodeOperatorWatermark updated{source_id, next_index};
+    if (!batch.WriteMasternodeOperatorWatermark(updated)) return false;
+    m_mn_operator_watermark = updated;
+    return true;
+}
+
+MasternodeOperatorKeyStatus CWallet::TopUpMasternodeOperatorLookahead()
+{
+    AssertLockHeld(cs_wallet);
+    std::vector<unsigned char> source_id;
+    const ScriptPubKeyMan* source{GetMasternodeOperatorKeySource(&source_id)};
+    if (!source) return MasternodeOperatorKeyStatus::NOT_SUPPORTED;
+    if (IsLocked()) return MasternodeOperatorKeyStatus::WALLET_LOCKED;
+
+    const uint32_t next{GetMasternodeOperatorNextIndex(source_id)};
+    const uint32_t lookahead_end{
+        std::min<uint32_t>(next + MASTERNODE_OPERATOR_GAP_LIMIT, MASTERNODE_OPERATOR_MAX_INDEX)};
+    if (next >= lookahead_end) return MasternodeOperatorKeyStatus::EXHAUSTED;
+    if (m_mn_operator_lookahead && m_mn_operator_lookahead->source_id == source_id &&
+        m_mn_operator_lookahead->base_index == next &&
+        m_mn_operator_lookahead->public_keys.size() == lookahead_end - next) {
+        return MasternodeOperatorKeyStatus::SUCCESS;
+    }
+
+    MasternodeOperatorLookahead lookahead{source_id, next, {}};
+    lookahead.public_keys.reserve(lookahead_end - next);
+    const auto status{source->DeriveMasternodeOperatorKeys(MasternodeOperatorCoinType(), next, lookahead_end,
+                                                           [&lookahead](uint32_t, const CBLSSecretKey& secret) {
+                                                               lookahead.public_keys.push_back(
+                                                                   CanonicalOperatorKeyBytes(secret.GetPublicKey()));
+                                                               return true;
+                                                           })};
+    if (status != MasternodeOperatorKeyStatus::SUCCESS) return status;
+    if (lookahead.public_keys.size() != lookahead_end - next) return MasternodeOperatorKeyStatus::DERIVATION_ERROR;
+    if (!WalletBatch(GetDatabase()).WriteMasternodeOperatorLookahead(lookahead)) {
+        return MasternodeOperatorKeyStatus::DATABASE_ERROR;
+    }
+    m_mn_operator_lookahead = std::move(lookahead);
+    return MasternodeOperatorKeyStatus::SUCCESS;
+}
+
+void CWallet::MaybeAdvanceMasternodeOperatorWatermark(const CTransaction& tx, WalletBatch& batch)
+{
+    AssertLockHeld(cs_wallet);
+    if (tx.nType != TRANSACTION_PROVIDER_REGISTER && tx.nType != TRANSACTION_PROVIDER_UPDATE_REGISTRAR) return;
+    // Without a lookahead nothing can be matched; recognition is best-effort
+    // by design, so nothing is tracked for later either.
+    if (!m_mn_operator_lookahead) return;
+
+    CBLSPublicKey public_key;
+    if (tx.nType == TRANSACTION_PROVIDER_REGISTER) {
+        const auto payload{GetTxPayload<CProRegTx>(tx)};
+        if (!payload) return;
+        public_key = payload->pubKeyOperator.Get();
+    } else {
+        const auto payload{GetTxPayload<CProUpRegTx>(tx)};
+        if (!payload) return;
+        public_key = payload->pubKeyOperator.Get();
+    }
+    if (!public_key.IsValid()) return;
+
+    // Canonical bytes make this a key-value comparison: a legacy-scheme wire
+    // encoding of a lookahead key cannot cause a miss.
+    const auto target{CanonicalOperatorKeyBytes(public_key)};
+    const auto& keys{m_mn_operator_lookahead->public_keys};
+    const auto it{std::find(keys.begin(), keys.end(), target)};
+    if (it == keys.end()) return;
+    const uint32_t index{m_mn_operator_lookahead->base_index + static_cast<uint32_t>(it - keys.begin())};
+
+    // Only trust a lookahead that belongs to the active seed.
+    std::vector<unsigned char> source_id;
+    const ScriptPubKeyMan* source{GetMasternodeOperatorKeySource(&source_id)};
+    if (!source || source_id != m_mn_operator_lookahead->source_id) {
+        return;
+    }
+    if (index < GetMasternodeOperatorNextIndex(source_id)) return; // already consumed
+
+    // The write lands before the in-memory watermark moves; a failed write is
+    // retried the next time a transaction with this key is synced.
+    if (!RaiseMasternodeOperatorWatermark(source_id, index + 1, batch)) {
+        WalletLogPrintf("Failed to persist masternode operator watermark for index %u\n", index);
+        return;
+    }
+    WalletLogPrintf("Masternode operator key index %u seen in provider transaction %s; watermark advanced to %u\n",
+                    index, tx.GetHash().ToString(), index + 1);
+}
+
+interfaces::MasternodeOperatorKeyResult CWallet::GetNewMasternodeOperatorKey(
+    const std::function<bool(const CBLSPublicKey&)>& is_in_use)
+{
+    interfaces::MasternodeOperatorKeyResult result;
+    const uint32_t coin_type{MasternodeOperatorCoinType()};
+
+    uint32_t candidate{0};
+    {
+        LOCK(cs_wallet);
+        std::vector<unsigned char> source_id;
+        const ScriptPubKeyMan* source{GetMasternodeOperatorKeySource(&source_id)};
+        if (!source) {
+            result.status = MasternodeOperatorKeyStatus::NOT_SUPPORTED;
+            return result;
+        }
+        if (IsLocked()) {
+            result.status = MasternodeOperatorKeyStatus::WALLET_LOCKED;
+            return result;
+        }
+        candidate = GetMasternodeOperatorNextIndex(source_id);
+    }
+
+    if (is_in_use) {
+        // Gap-limit scan: consult the caller's predicate (typically the
+        // current masternode list) from the watermark upward and issue only
+        // above every index it reports in use, so a restored wallet cannot
+        // re-issue a key that is demonstrably active. The predicate is
+        // queried without cs_wallet held because it may read node chainstate.
+        uint32_t scan_index{candidate};
+        uint32_t consecutive_misses{0};
+        while (consecutive_misses < MASTERNODE_OPERATOR_GAP_LIMIT) {
+            if (scan_index >= MASTERNODE_OPERATOR_MAX_INDEX) {
+                result.status = MasternodeOperatorKeyStatus::EXHAUSTED;
+                return result;
+            }
+            const uint32_t chunk_end{
+                std::min(scan_index + MASTERNODE_OPERATOR_GAP_LIMIT, MASTERNODE_OPERATOR_MAX_INDEX)};
+            std::vector<CBLSPublicKey> chunk;
+            chunk.reserve(chunk_end - scan_index);
+            {
+                LOCK(cs_wallet);
+                const ScriptPubKeyMan* source{GetMasternodeOperatorKeySource()};
+                if (!source) {
+                    result.status = MasternodeOperatorKeyStatus::NOT_SUPPORTED;
+                    return result;
+                }
+                const auto status{source->DeriveMasternodeOperatorKeys(
+                    coin_type, scan_index, chunk_end, [&chunk](uint32_t, const CBLSSecretKey& secret) {
+                        chunk.push_back(secret.GetPublicKey());
+                        return true;
+                    })};
+                if (status != MasternodeOperatorKeyStatus::SUCCESS) {
+                    result.status = status;
+                    return result;
+                }
+            }
+            for (uint32_t offset{0}; offset < chunk.size() && consecutive_misses < MASTERNODE_OPERATOR_GAP_LIMIT;
+                 ++offset) {
+                if (is_in_use(chunk[offset])) {
+                    candidate = scan_index + offset + 1;
+                    consecutive_misses = 0;
+                } else {
+                    ++consecutive_misses;
+                }
+            }
+            scan_index = chunk_end;
+        }
+    }
+
+    LOCK(cs_wallet);
+    std::vector<unsigned char> source_id;
+    const ScriptPubKeyMan* source{GetMasternodeOperatorKeySource(&source_id)};
+    if (!source) {
+        result.status = MasternodeOperatorKeyStatus::NOT_SUPPORTED;
+        return result;
+    }
+    // The wallet may have been locked while the predicate ran without
+    // cs_wallet; nothing has been consumed yet, so fail without burning an
+    // index the seed can no longer derive.
+    if (IsLocked()) {
+        result.status = MasternodeOperatorKeyStatus::WALLET_LOCKED;
+        return result;
+    }
+    // The sync hook may have advanced the watermark while the predicate ran;
+    // never issue below it. A candidate raised this way skips a fresh
+    // predicate query, matching the accepted race with concurrent
+    // registrations (consensus rejects a genuine duplicate).
+    candidate = std::max(candidate, GetMasternodeOperatorNextIndex(source_id));
+    if (candidate >= MASTERNODE_OPERATOR_MAX_INDEX) {
+        result.status = MasternodeOperatorKeyStatus::EXHAUSTED;
+        return result;
+    }
+
+    CBLSSecretKey secret;
+    const auto status{source->DeriveMasternodeOperatorKey(coin_type, candidate, secret)};
+    if (status != MasternodeOperatorKeyStatus::SUCCESS) {
+        result.status = status;
+        return result;
+    }
+
+    // The watermark is recorded before the secret is ever returned;
+    // consumption is permanent and never rolled back.
+    WalletBatch batch(GetDatabase());
+    if (!RaiseMasternodeOperatorWatermark(source_id, candidate + 1, batch)) {
+        secret.Reset();
+        result.status = MasternodeOperatorKeyStatus::DATABASE_ERROR;
+        return result;
+    }
+    // Keep the recognition lookahead ahead of the new watermark; a failure
+    // only degrades opportunistic recognition, never the issued key.
+    if (const auto lookahead_status{TopUpMasternodeOperatorLookahead()};
+        lookahead_status != MasternodeOperatorKeyStatus::SUCCESS) {
+        WalletLogPrintf("Failed to refresh masternode operator lookahead (status %d)\n",
+                        static_cast<int>(lookahead_status));
+    }
+
+    result.key.secret_key.resize(CBLSSecretKey::SerSize);
+    if (!secret.SerializeTo(result.key.secret_key)) {
+        secret.Reset();
+        result.key.secret_key.clear();
+        result.status = MasternodeOperatorKeyStatus::DERIVATION_ERROR;
+        return result;
+    }
+    result.key.public_key = CanonicalOperatorKeyBytes(secret.GetPublicKey());
+    secret.Reset();
+    result.key.path = MasternodeOperatorKeyPath(coin_type, candidate);
+    result.status = MasternodeOperatorKeyStatus::SUCCESS;
+    return result;
+}
+
+interfaces::MasternodeOperatorKeyResult CWallet::GetMasternodeOperatorKey(const CBLSPublicKey& public_key)
+{
+    interfaces::MasternodeOperatorKeyResult result;
+    if (!public_key.IsValid()) {
+        result.status = MasternodeOperatorKeyStatus::INVALID_KEY;
+        return result;
+    }
+
+    LOCK(cs_wallet);
+    std::vector<unsigned char> source_id;
+    const ScriptPubKeyMan* source{GetMasternodeOperatorKeySource(&source_id)};
+    if (!source) {
+        result.status = MasternodeOperatorKeyStatus::NOT_SUPPORTED;
+        return result;
+    }
+    if (IsLocked()) {
+        result.status = MasternodeOperatorKeyStatus::WALLET_LOCKED;
+        return result;
+    }
+    // Only consumed indexes - those below the watermark - are addressable:
+    // exposure equals consumption, and nothing above the watermark has been
+    // exposed.
+    const uint32_t next{GetMasternodeOperatorNextIndex(source_id)};
+    if (next == 0) {
+        result.status = MasternodeOperatorKeyStatus::NOT_FOUND;
+        return result;
+    }
+
+    const uint32_t coin_type{MasternodeOperatorCoinType()};
+    const auto target{CanonicalOperatorKeyBytes(public_key)};
+    CBLSSecretKey found;
+    uint32_t found_index{0};
+    const auto status{source->DeriveMasternodeOperatorKeys(coin_type, 0, next,
+                                                           [&](uint32_t index, const CBLSSecretKey& secret) {
+                                                               if (CanonicalOperatorKeyBytes(secret.GetPublicKey()) !=
+                                                                   target) {
+                                                                   return true;
+                                                               }
+                                                               found = secret;
+                                                               found_index = index;
+                                                               return false;
+                                                           })};
+    if (status != MasternodeOperatorKeyStatus::SUCCESS) {
+        result.status = status;
+        return result;
+    }
+    if (!found.IsValid()) {
+        result.status = MasternodeOperatorKeyStatus::NOT_FOUND;
+        return result;
+    }
+
+    result.key.secret_key.resize(CBLSSecretKey::SerSize);
+    if (!found.SerializeTo(result.key.secret_key)) {
+        found.Reset();
+        result.key.secret_key.clear();
+        result.status = MasternodeOperatorKeyStatus::DERIVATION_ERROR;
+        return result;
+    }
+    found.Reset();
+    result.key.public_key = target;
+    result.key.path = MasternodeOperatorKeyPath(coin_type, found_index);
+    result.status = MasternodeOperatorKeyStatus::SUCCESS;
+    return result;
+}
+
+} // namespace wallet
diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp
index 98ec293ce611..867d8bd96c3a 100644
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -7,10 +7,8 @@
 #include <wallet/wallet.h>
 
 #include <blockfilter.h>
-#include <bls/bls.h>
 #include <chain.h>
 #include <chainparams.h>
-#include <evo/specialtx.h>
 #include <consensus/amount.h>
 #include <consensus/consensus.h>
 #include <crypto/common.h>
@@ -3841,363 +3839,6 @@ std::vector<const Governance::Object*> CWallet::GetGovernanceObjects()
     return vecObjects;
 }
 
-static uint32_t MasternodeOperatorCoinType()
-{
-    // 5 on mainnet, 1 everywhere else - the DashSync convention of using
-    // testnet's coin type for every non-mainnet network.
-    return static_cast<uint32_t>(Params().ExtCoinType());
-}
-
-static std::vector<unsigned char> CanonicalOperatorKeyBytes(const CBLSPublicKey& public_key)
-{
-    return public_key.ToByteVector(/*specificLegacyScheme=*/false);
-}
-
-bool CWallet::LoadMasternodeOperatorWatermark(const MasternodeOperatorWatermark& watermark)
-{
-    AssertLockHeld(cs_wallet);
-    if (watermark.source_id.empty() || watermark.next_index > MASTERNODE_OPERATOR_MAX_INDEX) return false;
-    m_mn_operator_watermark = watermark;
-    return true;
-}
-
-bool CWallet::LoadMasternodeOperatorLookahead(const MasternodeOperatorLookahead& lookahead)
-{
-    AssertLockHeld(cs_wallet);
-    if (lookahead.source_id.empty() || lookahead.public_keys.empty() ||
-        lookahead.public_keys.size() > MASTERNODE_OPERATOR_GAP_LIMIT ||
-        lookahead.base_index > MASTERNODE_OPERATOR_MAX_INDEX - lookahead.public_keys.size()) {
-        return false;
-    }
-    for (const auto& public_key : lookahead.public_keys) {
-        CBLSPublicKey parsed;
-        parsed.SetBytes(public_key, /*specificLegacyScheme=*/false);
-        if (!parsed.IsValid() || CanonicalOperatorKeyBytes(parsed) != public_key) return false;
-    }
-    m_mn_operator_lookahead = lookahead;
-    return true;
-}
-
-ScriptPubKeyMan* CWallet::GetMasternodeOperatorKeySource(std::vector<unsigned char>* source_id_out) const
-{
-    AssertLockHeld(cs_wallet);
-    if (IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS) || IsWalletFlagSet(WALLET_FLAG_EXTERNAL_SIGNER)) {
-        return nullptr;
-    }
-
-    ScriptPubKeyMan* source{nullptr};
-    std::optional<std::vector<unsigned char>> source_id;
-    for (const auto& [id, spk_man] : m_spk_managers) {
-        std::vector<unsigned char> candidate;
-        const auto status{spk_man->GetMasternodeOperatorKeySource(candidate)};
-        if (status == MasternodeOperatorKeySourceStatus::AMBIGUOUS) return nullptr;
-        if (status == MasternodeOperatorKeySourceStatus::NONE) continue;
-        if (!source_id) source_id = candidate;
-        if (*source_id != candidate) return nullptr;
-        if (!source) source = spk_man.get();
-    }
-    if (source && source_id_out) *source_id_out = std::move(*source_id);
-    return source;
-}
-
-bool CWallet::HasMasternodeOperatorKeySource() const
-{
-    LOCK(cs_wallet);
-    return GetMasternodeOperatorKeySource() != nullptr;
-}
-
-uint32_t CWallet::GetMasternodeOperatorNextIndex(const std::vector<unsigned char>& source_id) const
-{
-    AssertLockHeld(cs_wallet);
-    if (!m_mn_operator_watermark || m_mn_operator_watermark->source_id != source_id) return 0;
-    return m_mn_operator_watermark->next_index;
-}
-
-bool CWallet::RaiseMasternodeOperatorWatermark(const std::vector<unsigned char>& source_id, uint32_t next_index,
-                                               WalletBatch& batch)
-{
-    AssertLockHeld(cs_wallet);
-    if (next_index <= GetMasternodeOperatorNextIndex(source_id)) return true;
-    const MasternodeOperatorWatermark updated{source_id, next_index};
-    if (!batch.WriteMasternodeOperatorWatermark(updated)) return false;
-    m_mn_operator_watermark = updated;
-    return true;
-}
-
-MasternodeOperatorKeyStatus CWallet::TopUpMasternodeOperatorLookahead()
-{
-    AssertLockHeld(cs_wallet);
-    std::vector<unsigned char> source_id;
-    ScriptPubKeyMan* source{GetMasternodeOperatorKeySource(&source_id)};
-    if (!source) return MasternodeOperatorKeyStatus::NOT_SUPPORTED;
-    if (IsLocked()) return MasternodeOperatorKeyStatus::WALLET_LOCKED;
-
-    const uint32_t next{GetMasternodeOperatorNextIndex(source_id)};
-    const uint32_t end{std::min<uint32_t>(next + MASTERNODE_OPERATOR_GAP_LIMIT, MASTERNODE_OPERATOR_MAX_INDEX)};
-    if (next >= end) return MasternodeOperatorKeyStatus::EXHAUSTED;
-    if (m_mn_operator_lookahead && m_mn_operator_lookahead->source_id == source_id &&
-        m_mn_operator_lookahead->base_index == next && m_mn_operator_lookahead->public_keys.size() == end - next) {
-        return MasternodeOperatorKeyStatus::SUCCESS;
-    }
-
-    MasternodeOperatorLookahead lookahead{source_id, next, {}};
-    lookahead.public_keys.reserve(end - next);
-    const auto status{source->DeriveMasternodeOperatorKeys(MasternodeOperatorCoinType(), next, end,
-                                                           [&lookahead](uint32_t, const CBLSSecretKey& secret) {
-                                                               lookahead.public_keys.push_back(
-                                                                   CanonicalOperatorKeyBytes(secret.GetPublicKey()));
-                                                               return true;
-                                                           })};
-    if (status != MasternodeOperatorKeyStatus::SUCCESS) return status;
-    if (lookahead.public_keys.size() != end - next) return MasternodeOperatorKeyStatus::DERIVATION_ERROR;
-    if (!WalletBatch(GetDatabase()).WriteMasternodeOperatorLookahead(lookahead)) {
-        return MasternodeOperatorKeyStatus::DATABASE_ERROR;
-    }
-    m_mn_operator_lookahead = std::move(lookahead);
-    return MasternodeOperatorKeyStatus::SUCCESS;
-}
-
-void CWallet::MaybeAdvanceMasternodeOperatorWatermark(const CTransaction& tx, WalletBatch& batch)
-{
-    AssertLockHeld(cs_wallet);
-    if (tx.nType != TRANSACTION_PROVIDER_REGISTER && tx.nType != TRANSACTION_PROVIDER_UPDATE_REGISTRAR) return;
-    // Without a lookahead nothing can be matched; recognition is best-effort
-    // by design, so nothing is tracked for later either.
-    if (!m_mn_operator_lookahead) return;
-
-    CBLSPublicKey public_key;
-    if (tx.nType == TRANSACTION_PROVIDER_REGISTER) {
-        const auto payload{GetTxPayload<CProRegTx>(tx)};
-        if (!payload) return;
-        public_key = payload->pubKeyOperator.Get();
-    } else {
-        const auto payload{GetTxPayload<CProUpRegTx>(tx)};
-        if (!payload) return;
-        public_key = payload->pubKeyOperator.Get();
-    }
-    if (!public_key.IsValid()) return;
-
-    // Canonical bytes make this a key-value comparison: a legacy-scheme wire
-    // encoding of a lookahead key cannot cause a miss.
-    const auto target{CanonicalOperatorKeyBytes(public_key)};
-    const auto& keys{m_mn_operator_lookahead->public_keys};
-    const auto it{std::find(keys.begin(), keys.end(), target)};
-    if (it == keys.end()) return;
-    const uint32_t index{m_mn_operator_lookahead->base_index + static_cast<uint32_t>(it - keys.begin())};
-
-    // Only trust a lookahead that belongs to the active seed.
-    std::vector<unsigned char> source_id;
-    ScriptPubKeyMan* source{GetMasternodeOperatorKeySource(&source_id)};
-    if (!source || source_id != m_mn_operator_lookahead->source_id) {
-        return;
-    }
-    if (index < GetMasternodeOperatorNextIndex(source_id)) return; // already consumed
-
-    // The write lands before the in-memory watermark moves; a failed write is
-    // retried the next time a transaction with this key is synced.
-    if (!RaiseMasternodeOperatorWatermark(source_id, index + 1, batch)) {
-        WalletLogPrintf("Failed to persist masternode operator watermark for index %u\n", index);
-        return;
-    }
-    WalletLogPrintf("Masternode operator key index %u seen in provider transaction %s; watermark advanced to %u\n",
-                    index, tx.GetHash().ToString(), index + 1);
-}
-
-interfaces::MasternodeOperatorKeyResult CWallet::GetNewMasternodeOperatorKey(
-    const std::function<bool(const CBLSPublicKey&)>& is_in_use)
-{
-    interfaces::MasternodeOperatorKeyResult result;
-    const uint32_t coin_type{MasternodeOperatorCoinType()};
-
-    uint32_t candidate{0};
-    {
-        LOCK(cs_wallet);
-        std::vector<unsigned char> source_id;
-        ScriptPubKeyMan* source{GetMasternodeOperatorKeySource(&source_id)};
-        if (!source) {
-            result.status = MasternodeOperatorKeyStatus::NOT_SUPPORTED;
-            return result;
-        }
-        if (IsLocked()) {
-            result.status = MasternodeOperatorKeyStatus::WALLET_LOCKED;
-            return result;
-        }
-        candidate = GetMasternodeOperatorNextIndex(source_id);
-    }
-
-    if (is_in_use) {
-        // Gap-limit scan: consult the caller's predicate (typically the
-        // current masternode list) from the watermark upward and issue only
-        // above every index it reports in use, so a restored wallet cannot
-        // re-issue a key that is demonstrably active. The predicate is
-        // queried without cs_wallet held because it may read node chainstate.
-        uint32_t scan_index{candidate};
-        uint32_t consecutive_misses{0};
-        while (consecutive_misses < MASTERNODE_OPERATOR_GAP_LIMIT) {
-            if (scan_index >= MASTERNODE_OPERATOR_MAX_INDEX) {
-                result.status = MasternodeOperatorKeyStatus::EXHAUSTED;
-                return result;
-            }
-            const uint32_t chunk_end{
-                std::min(scan_index + MASTERNODE_OPERATOR_GAP_LIMIT, MASTERNODE_OPERATOR_MAX_INDEX)};
-            std::vector<CBLSPublicKey> chunk;
-            chunk.reserve(chunk_end - scan_index);
-            {
-                LOCK(cs_wallet);
-                ScriptPubKeyMan* source{GetMasternodeOperatorKeySource()};
-                if (!source) {
-                    result.status = MasternodeOperatorKeyStatus::NOT_SUPPORTED;
-                    return result;
-                }
-                const auto status{source->DeriveMasternodeOperatorKeys(
-                    coin_type, scan_index, chunk_end, [&chunk](uint32_t, const CBLSSecretKey& secret) {
-                        chunk.push_back(secret.GetPublicKey());
-                        return true;
-                    })};
-                if (status != MasternodeOperatorKeyStatus::SUCCESS) {
-                    result.status = status;
-                    return result;
-                }
-            }
-            for (uint32_t offset{0}; offset < chunk.size() && consecutive_misses < MASTERNODE_OPERATOR_GAP_LIMIT;
-                 ++offset) {
-                if (is_in_use(chunk[offset])) {
-                    candidate = scan_index + offset + 1;
-                    consecutive_misses = 0;
-                } else {
-                    ++consecutive_misses;
-                }
-            }
-            scan_index = chunk_end;
-        }
-    }
-
-    LOCK(cs_wallet);
-    std::vector<unsigned char> source_id;
-    ScriptPubKeyMan* source{GetMasternodeOperatorKeySource(&source_id)};
-    if (!source) {
-        result.status = MasternodeOperatorKeyStatus::NOT_SUPPORTED;
-        return result;
-    }
-    // The wallet may have been locked while the predicate ran without
-    // cs_wallet; nothing has been consumed yet, so fail without burning an
-    // index the seed can no longer derive.
-    if (IsLocked()) {
-        result.status = MasternodeOperatorKeyStatus::WALLET_LOCKED;
-        return result;
-    }
-    // The sync hook may have advanced the watermark while the predicate ran;
-    // never issue below it. A candidate raised this way skips a fresh
-    // predicate query, matching the accepted race with concurrent
-    // registrations (consensus rejects a genuine duplicate).
-    candidate = std::max(candidate, GetMasternodeOperatorNextIndex(source_id));
-    if (candidate >= MASTERNODE_OPERATOR_MAX_INDEX) {
-        result.status = MasternodeOperatorKeyStatus::EXHAUSTED;
-        return result;
-    }
-
-    CBLSSecretKey secret;
-    const auto status{source->DeriveMasternodeOperatorKey(coin_type, candidate, secret)};
-    if (status != MasternodeOperatorKeyStatus::SUCCESS) {
-        result.status = status;
-        return result;
-    }
-
-    // The watermark is recorded before the secret is ever returned;
-    // consumption is permanent and never rolled back.
-    WalletBatch batch(GetDatabase());
-    if (!RaiseMasternodeOperatorWatermark(source_id, candidate + 1, batch)) {
-        secret.Reset();
-        result.status = MasternodeOperatorKeyStatus::DATABASE_ERROR;
-        return result;
-    }
-    // Keep the recognition lookahead ahead of the new watermark; a failure
-    // only degrades opportunistic recognition, never the issued key.
-    if (const auto lookahead_status{TopUpMasternodeOperatorLookahead()};
-        lookahead_status != MasternodeOperatorKeyStatus::SUCCESS) {
-        WalletLogPrintf("Failed to refresh masternode operator lookahead (status %d)\n",
-                        static_cast<int>(lookahead_status));
-    }
-
-    result.key.secret_key.resize(CBLSSecretKey::SerSize);
-    if (!secret.SerializeTo(result.key.secret_key)) {
-        secret.Reset();
-        result.key.secret_key.clear();
-        result.status = MasternodeOperatorKeyStatus::DERIVATION_ERROR;
-        return result;
-    }
-    result.key.public_key = CanonicalOperatorKeyBytes(secret.GetPublicKey());
-    secret.Reset();
-    result.key.path = MasternodeOperatorKeyPath(coin_type, candidate);
-    result.status = MasternodeOperatorKeyStatus::SUCCESS;
-    return result;
-}
-
-interfaces::MasternodeOperatorKeyResult CWallet::GetMasternodeOperatorKey(const CBLSPublicKey& public_key)
-{
-    interfaces::MasternodeOperatorKeyResult result;
-    if (!public_key.IsValid()) {
-        result.status = MasternodeOperatorKeyStatus::INVALID_KEY;
-        return result;
-    }
-
-    LOCK(cs_wallet);
-    std::vector<unsigned char> source_id;
-    ScriptPubKeyMan* source{GetMasternodeOperatorKeySource(&source_id)};
-    if (!source) {
-        result.status = MasternodeOperatorKeyStatus::NOT_SUPPORTED;
-        return result;
-    }
-    if (IsLocked()) {
-        result.status = MasternodeOperatorKeyStatus::WALLET_LOCKED;
-        return result;
-    }
-    // Only consumed indexes - those below the watermark - are addressable:
-    // exposure equals consumption, and nothing above the watermark has been
-    // exposed.
-    const uint32_t next{GetMasternodeOperatorNextIndex(source_id)};
-    if (next == 0) {
-        result.status = MasternodeOperatorKeyStatus::NOT_FOUND;
-        return result;
-    }
-
-    const uint32_t coin_type{MasternodeOperatorCoinType()};
-    const auto target{CanonicalOperatorKeyBytes(public_key)};
-    CBLSSecretKey found;
-    uint32_t found_index{0};
-    const auto status{source->DeriveMasternodeOperatorKeys(coin_type, 0, next,
-                                                           [&](uint32_t index, const CBLSSecretKey& secret) {
-                                                               if (CanonicalOperatorKeyBytes(secret.GetPublicKey()) !=
-                                                                   target) {
-                                                                   return true;
-                                                               }
-                                                               found = secret;
-                                                               found_index = index;
-                                                               return false;
-                                                           })};
-    if (status != MasternodeOperatorKeyStatus::SUCCESS) {
-        result.status = status;
-        return result;
-    }
-    if (!found.IsValid()) {
-        result.status = MasternodeOperatorKeyStatus::NOT_FOUND;
-        return result;
-    }
-
-    result.key.secret_key.resize(CBLSSecretKey::SerSize);
-    if (!found.SerializeTo(result.key.secret_key)) {
-        found.Reset();
-        result.key.secret_key.clear();
-        result.status = MasternodeOperatorKeyStatus::DERIVATION_ERROR;
-        return result;
-    }
-    found.Reset();
-    result.key.public_key = target;
-    result.key.path = MasternodeOperatorKeyPath(coin_type, found_index);
-    result.status = MasternodeOperatorKeyStatus::SUCCESS;
-    return result;
-}
-
 CKeyPool::CKeyPool()
 {
     nTime = GetTime();
diff --git a/test/util/data/non-backported.txt b/test/util/data/non-backported.txt
index 045d707ce629..b36aeb8f119f 100644
--- a/test/util/data/non-backported.txt
+++ b/test/util/data/non-backported.txt
@@ -87,5 +87,6 @@ src/wallet/bip39*
 src/wallet/coinjoin.*
 src/wallet/hdchain.*
 src/wallet/masternode_operator.*
+src/wallet/mnoperator.cpp
 src/wallet/test/masternode_operator_tests.cpp
 src/hash_x11.h

From 0ae8ebf9043ed27c7891f51d8b8cbabe5c634cad Mon Sep 17 00:00:00 2001
From: pasta <pasta@dashboost.org>
Date: Tue, 18 Aug 2026 13:00:42 -0500
Subject: [PATCH 4/6] refactor(wallet): align masternode operator filenames

---
 src/Makefile.am                                             | 4 ++--
 src/wallet/{mnoperator.cpp => masternode_operator.cpp}      | 0
 .../{masternode_operator.h => masternode_operator_types.h}  | 6 +++---
 src/wallet/scriptpubkeyman.h                                | 2 +-
 src/wallet/test/masternode_operator_tests.cpp               | 2 +-
 src/wallet/wallet.h                                         | 2 +-
 test/util/data/non-backported.txt                           | 3 +--
 7 files changed, 9 insertions(+), 10 deletions(-)
 rename src/wallet/{mnoperator.cpp => masternode_operator.cpp} (100%)
 rename src/wallet/{masternode_operator.h => masternode_operator_types.h} (95%)

diff --git a/src/Makefile.am b/src/Makefile.am
index 5e57465859c1..997f65a5350b 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -479,7 +479,7 @@ BITCOIN_CORE_H = \
   wallet/hdchain.h \
   wallet/ismine.h \
   wallet/load.h \
-  wallet/masternode_operator.h \
+  wallet/masternode_operator_types.h \
   wallet/receive.h \
   wallet/rpc/util.h \
   wallet/rpc/wallet.h \
@@ -711,7 +711,7 @@ libbitcoin_wallet_a_SOURCES = \
   wallet/hdchain.cpp \
   wallet/interfaces.cpp \
   wallet/load.cpp \
-  wallet/mnoperator.cpp \
+  wallet/masternode_operator.cpp \
   wallet/receive.cpp \
   wallet/rpc/addresses.cpp \
   wallet/rpc/backup.cpp \
diff --git a/src/wallet/mnoperator.cpp b/src/wallet/masternode_operator.cpp
similarity index 100%
rename from src/wallet/mnoperator.cpp
rename to src/wallet/masternode_operator.cpp
diff --git a/src/wallet/masternode_operator.h b/src/wallet/masternode_operator_types.h
similarity index 95%
rename from src/wallet/masternode_operator.h
rename to src/wallet/masternode_operator_types.h
index 98de8dfd7d4f..e080f04ed9a5 100644
--- a/src/wallet/masternode_operator.h
+++ b/src/wallet/masternode_operator_types.h
@@ -2,8 +2,8 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
-#ifndef BITCOIN_WALLET_MASTERNODE_OPERATOR_H
-#define BITCOIN_WALLET_MASTERNODE_OPERATOR_H
+#ifndef BITCOIN_WALLET_MASTERNODE_OPERATOR_TYPES_H
+#define BITCOIN_WALLET_MASTERNODE_OPERATOR_TYPES_H
 
 #include <interfaces/masternode_operator.h>
 #include <serialize.h>
@@ -87,4 +87,4 @@ struct MasternodeOperatorLookahead {
 
 } // namespace wallet
 
-#endif // BITCOIN_WALLET_MASTERNODE_OPERATOR_H
+#endif // BITCOIN_WALLET_MASTERNODE_OPERATOR_TYPES_H
diff --git a/src/wallet/scriptpubkeyman.h b/src/wallet/scriptpubkeyman.h
index 3f96eb29928f..e93876606204 100644
--- a/src/wallet/scriptpubkeyman.h
+++ b/src/wallet/scriptpubkeyman.h
@@ -17,7 +17,7 @@
 #include <wallet/crypter.h>
 #include <wallet/hdchain.h>
 #include <wallet/ismine.h>
-#include <wallet/masternode_operator.h>
+#include <wallet/masternode_operator_types.h>
 #include <wallet/walletdb.h>
 #include <wallet/walletutil.h>
 
diff --git a/src/wallet/test/masternode_operator_tests.cpp b/src/wallet/test/masternode_operator_tests.cpp
index c351d21c2975..bffc3ad35a0e 100644
--- a/src/wallet/test/masternode_operator_tests.cpp
+++ b/src/wallet/test/masternode_operator_tests.cpp
@@ -17,7 +17,7 @@
 #include <validation.h>
 #include <wallet/bip39.h>
 #include <wallet/hdchain.h>
-#include <wallet/masternode_operator.h>
+#include <wallet/masternode_operator_types.h>
 #include <wallet/scriptpubkeyman.h>
 #include <wallet/test/wallet_test_fixture.h>
 #include <wallet/wallet.h>
diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h
index d34ac716ab45..775ade5ca96e 100644
--- a/src/wallet/wallet.h
+++ b/src/wallet/wallet.h
@@ -28,7 +28,7 @@
 #include <wallet/crypter.h>
 #include <wallet/coinselection.h>
 #include <external_signer.h>
-#include <wallet/masternode_operator.h>
+#include <wallet/masternode_operator_types.h>
 #include <wallet/scriptpubkeyman.h>
 #include <wallet/transaction.h>
 #include <wallet/walletdb.h>
diff --git a/test/util/data/non-backported.txt b/test/util/data/non-backported.txt
index b36aeb8f119f..d015cb9ebed7 100644
--- a/test/util/data/non-backported.txt
+++ b/test/util/data/non-backported.txt
@@ -86,7 +86,6 @@ src/util/wpipe.*
 src/wallet/bip39*
 src/wallet/coinjoin.*
 src/wallet/hdchain.*
-src/wallet/masternode_operator.*
-src/wallet/mnoperator.cpp
+src/wallet/masternode_operator*
 src/wallet/test/masternode_operator_tests.cpp
 src/hash_x11.h

From 4a03d9f56dd696752bc5acb1b98b3417ff8f6922 Mon Sep 17 00:00:00 2001
From: pasta <pasta@dashboost.org>
Date: Tue, 18 Aug 2026 14:34:41 -0500
Subject: [PATCH 5/6] fix(wallet): enforce operator issuance lock contract

---
 src/wallet/masternode_operator.cpp | 1 +
 src/wallet/wallet.h                | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/wallet/masternode_operator.cpp b/src/wallet/masternode_operator.cpp
index 945270ced958..01e19cae11ea 100644
--- a/src/wallet/masternode_operator.cpp
+++ b/src/wallet/masternode_operator.cpp
@@ -186,6 +186,7 @@ void CWallet::MaybeAdvanceMasternodeOperatorWatermark(const CTransaction& tx, Wa
 interfaces::MasternodeOperatorKeyResult CWallet::GetNewMasternodeOperatorKey(
     const std::function<bool(const CBLSPublicKey&)>& is_in_use)
 {
+    AssertLockNotHeld(cs_wallet);
     interfaces::MasternodeOperatorKeyResult result;
     const uint32_t coin_type{MasternodeOperatorCoinType()};
 
diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h
index 775ade5ca96e..dd7e3c57bae8 100644
--- a/src/wallet/wallet.h
+++ b/src/wallet/wallet.h
@@ -1054,7 +1054,7 @@ class CWallet final : public WalletStorage, public interfaces::Chain::Notificati
      *  can query node chainstate, and issuance skips past every index it
      *  reports in use (gap-limit scan). */
     interfaces::MasternodeOperatorKeyResult GetNewMasternodeOperatorKey(
-        const std::function<bool(const CBLSPublicKey&)>& is_in_use);
+        const std::function<bool(const CBLSPublicKey&)>& is_in_use) EXCLUSIVE_LOCKS_REQUIRED(!cs_wallet);
     /** Re-derive a previously consumed operator key (an index below the
      *  watermark) by its public key. Read-only. */
     interfaces::MasternodeOperatorKeyResult GetMasternodeOperatorKey(const CBLSPublicKey& public_key);

From 11f564b94ab65bea4054dd8d7f6102d451aa6c17 Mon Sep 17 00:00:00 2001
From: pasta <pasta@dashboost.org>
Date: Tue, 18 Aug 2026 14:37:33 -0500
Subject: [PATCH 6/6] refactor(wallet): rely on operator lock annotation

---
 src/wallet/masternode_operator.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/wallet/masternode_operator.cpp b/src/wallet/masternode_operator.cpp
index 01e19cae11ea..945270ced958 100644
--- a/src/wallet/masternode_operator.cpp
+++ b/src/wallet/masternode_operator.cpp
@@ -186,7 +186,6 @@ void CWallet::MaybeAdvanceMasternodeOperatorWatermark(const CTransaction& tx, Wa
 interfaces::MasternodeOperatorKeyResult CWallet::GetNewMasternodeOperatorKey(
     const std::function<bool(const CBLSPublicKey&)>& is_in_use)
 {
-    AssertLockNotHeld(cs_wallet);
     interfaces::MasternodeOperatorKeyResult result;
     const uint32_t coin_type{MasternodeOperatorCoinType()};