feat(wallet): derive masternode operator keys from seed

src/Makefile.am

@@ -290,6 +290,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 \
@@ -500,6 +501,7 @@ BITCOIN_CORE_H = \
   wallet/fees.h \
   wallet/hdchain.h \
   wallet/load.h \
+  wallet/masternode_operator_types.h \
   wallet/platformkeys.h \
   wallet/platformtypes.h \
   wallet/receive.h \
@@ -741,6 +743,7 @@ libbitcoin_wallet_a_SOURCES = \
   wallet/hdchain.cpp \
   wallet/interfaces.cpp \
   wallet/load.cpp \
+  wallet/masternode_operator.cpp \
   wallet/platformkeys.cpp \
   wallet/receive.cpp \
   wallet/rpc/addresses.cpp \

src/Makefile.test.include

@@ -230,6 +230,7 @@ if ENABLE_WALLET
 BITCOIN_TESTS += \
   wallet/test/bip39_tests.cpp \
   wallet/test/coinjoin_tests.cpp \
+  wallet/test/masternode_operator_tests.cpp \
   wallet/test/platformkeys_tests.cpp \
   wallet/test/psbt_wallet_tests.cpp \
   wallet/test/spend_tests.cpp \

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);
 

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

src/interfaces/node.h

@@ -32,6 +32,7 @@
 
 class BanMan;
 class CBlockIndex;
+class CBLSPublicKey;
 class CDeterministicMNList;
 class CFeeRate;
 class CGovernanceObject;
@@ -182,6 +183,15 @@ class EVO
     virtual ProviderTxResult<ProviderTxSubmission> updateShare(Wallet& wallet, const SharedUpdateShareRequest& request) = 0;
     virtual ProviderTxResult<PreparedSharedConsent> prepareSharedRegistrarUpdate(
         Wallet& wallet, const SharedRegistrarUpdatePrepareRequest& 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) {}
 };
 

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
@@ -29,6 +30,7 @@
 #include <utility>
 #include <vector>
 
+class CBLSPublicKey;
 class CFeeRate;
 class CGovernanceVote;
 class CKey;
@@ -162,6 +164,22 @@ class Wallet
     virtual wallet::PlatformKeyResult<wallet::FriendshipXpub> ensureFriendshipReceivingKeychain(
         const wallet::FriendshipKeychainRequest& request) = 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 key counter that is not in use. The key counter 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
+    //! key counter) 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;

src/node/interfaces.cpp

@@ -335,6 +335,25 @@ class EVOImpl : public EVO
     {
         return evo::provider::PrepareSharedRegistrarUpdate(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;

src/qt/test/masternodewidgettests.cpp

@@ -195,6 +195,7 @@ class BlockingEVO final : public interfaces::EVO
     {
         return TestProviderError();
     }
+    bool isMasternodeOperatorKeyInUse(const CBLSPublicKey&) override { return false; }
 
     QSemaphore entered;
     QSemaphore proceed;

src/test/evo_deterministicmns_tests.cpp

@@ -1883,6 +1883,42 @@ 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.

src/wallet/interfaces.cpp

@@ -4,18 +4,23 @@
 
 #include <interfaces/wallet.h>
 
+#include <bls/bls.h>
 #include <chain.h>
 #include <chainparams.h>
 #include <coinjoin/client.h>
 #include <consensus/amount.h>
+#include <evo/deterministicmns.h>
 #include <interfaces/chain.h>
 #include <interfaces/handler.h>
+#include <masternode/sync.h>
+#include <node/context.h>
 #include <policy/fees.h>
 #include <primitives/transaction.h>
 #include <rpc/server.h>
 #include <script/standard.h>
 #include <support/allocators/secure.h>
 #include <sync.h>
+#include <txdb.h>
 #include <uint256.h>
 #include <util/check.h>
 #include <util/system.h>
@@ -26,19 +31,15 @@
 #include <wallet/coinjoin.h>
 #include <wallet/context.h>
 #include <wallet/fees.h>
-#include <wallet/types.h>
+#include <wallet/hdchain.h>
 #include <wallet/load.h>
 #include <wallet/receive.h>
 #include <wallet/rpc/wallet.h>
+#include <wallet/scriptpubkeyman.h>
 #include <wallet/spend.h>
+#include <wallet/types.h>
 #include <wallet/wallet.h>
-#include <wallet/hdchain.h>
-#include <wallet/scriptpubkeyman.h>
 #include <wallet/walletutil.h>
-#include <evo/deterministicmns.h>
-#include <masternode/sync.h>
-#include <txdb.h>
-#include <node/context.h>
 
 #include <algorithm>
 #include <memory>
@@ -267,6 +268,23 @@ class WalletImpl : public Wallet
     {
         return m_wallet->EnsureFriendshipReceivingKeychain(request);
     }
+    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);