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..997f65a5350b 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_types.h \
   wallet/receive.h \
   wallet/rpc/util.h \
   wallet/rpc/wallet.h \
@@ -709,6 +711,7 @@ libbitcoin_wallet_a_SOURCES = \
   wallet/hdchain.cpp \
   wallet/interfaces.cpp \
   wallet/load.cpp \
+  wallet/masternode_operator.cpp \
   wallet/receive.cpp \
   wallet/rpc/addresses.cpp \
   wallet/rpc/backup.cpp \
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/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/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/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.
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.cpp b/src/wallet/masternode_operator.cpp
new file mode 100644
index 000000000000..945270ced958
--- /dev/null
+++ b/src/wallet/masternode_operator.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/masternode_operator_types.h b/src/wallet/masternode_operator_types.h
new file mode 100644
index 000000000000..e080f04ed9a5
--- /dev/null
+++ b/src/wallet/masternode_operator_types.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_TYPES_H
+#define BITCOIN_WALLET_MASTERNODE_OPERATOR_TYPES_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_TYPES_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..e93876606204 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_types.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..bffc3ad35a0e
--- /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_types.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..867d8bd96c3a 100644
--- a/src/wallet/wallet.cpp
+++ b/src/wallet/wallet.cpp
@@ -1410,6 +1410,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 +3166,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 +3215,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 +3235,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 +3411,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)) {
diff --git a/src/wallet/wallet.h b/src/wallet/wallet.h
index 059e7712c6c4..dd7e3c57bae8 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_types.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) 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);
+
     /**
      * 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..d015cb9ebed7 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