From da3da1bb1bf4f868642cc4ca5aed6f8e2e0d5f10 Mon Sep 17 00:00:00 2001
From: Daniel Kraft <d@domob.eu>
Date: Tue, 16 Mar 2021 15:38:42 +0100
Subject: [PATCH 1/9] Move internal functions into anonymous namespace.

Wrap some of the functions used only in main into an anonymous namespace;
some of them were already marked as "static", others were not (but they
were still not needed from anywhere else).

This makes it immediately clear that those functions are only used in the
context of main.

FindUndoPos had a declaration first and the definition later, but it is
fine to just move the definition to where the declaration was.  This
simplifies the code further (and is a pure move in the context of
this commit).
---
 divi/src/main.cpp | 69 ++++++++++++++++++++++++-----------------------
 1 file changed, 36 insertions(+), 33 deletions(-)

diff --git a/divi/src/main.cpp b/divi/src/main.cpp
index a66520311..717071c42 100755
--- a/divi/src/main.cpp
+++ b/divi/src/main.cpp
@@ -1202,7 +1202,10 @@ void Misbehaving(NodeId pnode, int howmuch)
         LogPrintf("Misbehaving: %s (%d -> %d)\n", state->name, state->nMisbehavior - howmuch, state->nMisbehavior);
 }
 
-void static InvalidChainFound(CBlockIndex* pindexNew)
+namespace
+{
+
+void InvalidChainFound(CBlockIndex* pindexNew)
 {
     if (!pindexBestInvalid || pindexNew->nChainWork > pindexBestInvalid->nChainWork)
         pindexBestInvalid = pindexNew;
@@ -1217,7 +1220,7 @@ void static InvalidChainFound(CBlockIndex* pindexNew)
     CheckForkWarningConditions();
 }
 
-void static InvalidBlockFound(CBlockIndex* pindex, const CValidationState& state)
+void InvalidBlockFound(CBlockIndex* pindex, const CValidationState& state)
 {
     int nDoS = 0;
     if (state.IsInvalid(nDoS)) {
@@ -1237,7 +1240,7 @@ void static InvalidBlockFound(CBlockIndex* pindex, const CValidationState& state
     }
 }
 
-void static FlushBlockFile(bool fFinalize = false)
+void FlushBlockFile(bool fFinalize = false)
 {
     LOCK(cs_LastBlockFile);
 
@@ -1260,9 +1263,35 @@ void static FlushBlockFile(bool fFinalize = false)
     }
 }
 
-bool FindUndoPos(CValidationState& state, int nFile, CDiskBlockPos& pos, unsigned int nAddSize);
+bool FindUndoPos(CValidationState& state, int nFile, CDiskBlockPos& pos, unsigned int nAddSize)
+{
+    pos.nFile = nFile;
+
+    LOCK(cs_LastBlockFile);
+
+    unsigned int nNewSize;
+    pos.nPos = vinfoBlockFile[nFile].nUndoSize;
+    nNewSize = vinfoBlockFile[nFile].nUndoSize += nAddSize;
+    setDirtyFileInfo.insert(nFile);
+
+    unsigned int nOldChunks = (pos.nPos + UNDOFILE_CHUNK_SIZE - 1) / UNDOFILE_CHUNK_SIZE;
+    unsigned int nNewChunks = (nNewSize + UNDOFILE_CHUNK_SIZE - 1) / UNDOFILE_CHUNK_SIZE;
+    if (nNewChunks > nOldChunks) {
+        if (CheckDiskSpace(nNewChunks * UNDOFILE_CHUNK_SIZE - pos.nPos)) {
+            FILE* file = OpenUndoFile(pos);
+            if (file) {
+                LogPrintf("Pre-allocating up to position 0x%x in rev%05u.dat\n", nNewChunks * UNDOFILE_CHUNK_SIZE, pos.nFile);
+                AllocateFileRange(file, pos.nPos, nNewChunks * UNDOFILE_CHUNK_SIZE - pos.nPos);
+                fclose(file);
+            }
+        } else
+            return state.Error("out of disk space");
+    }
+
+    return true;
+}
 
-static int64_t nTimeTotal = 0;
+int64_t nTimeTotal = 0;
 
 void VerifyBestBlockIsAtPreviousBlock(const CBlockIndex* pindex, CCoinsViewCache& view)
 {
@@ -1391,6 +1420,8 @@ bool UpdateDBIndicesForNewBlock(
     return true;
 }
 
+} // anonymous namespace
+
 bool ConnectBlock(const CBlock& block, CValidationState& state, CBlockIndex* pindex, CCoinsViewCache& view, bool fJustCheck, bool fAlreadyChecked)
 {
     AssertLockHeld(cs_main);
@@ -2140,34 +2171,6 @@ bool FindBlockPos(CValidationState& state, CDiskBlockPos& pos, unsigned int nAdd
     return true;
 }
 
-bool FindUndoPos(CValidationState& state, int nFile, CDiskBlockPos& pos, unsigned int nAddSize)
-{
-    pos.nFile = nFile;
-
-    LOCK(cs_LastBlockFile);
-
-    unsigned int nNewSize;
-    pos.nPos = vinfoBlockFile[nFile].nUndoSize;
-    nNewSize = vinfoBlockFile[nFile].nUndoSize += nAddSize;
-    setDirtyFileInfo.insert(nFile);
-
-    unsigned int nOldChunks = (pos.nPos + UNDOFILE_CHUNK_SIZE - 1) / UNDOFILE_CHUNK_SIZE;
-    unsigned int nNewChunks = (nNewSize + UNDOFILE_CHUNK_SIZE - 1) / UNDOFILE_CHUNK_SIZE;
-    if (nNewChunks > nOldChunks) {
-        if (CheckDiskSpace(nNewChunks * UNDOFILE_CHUNK_SIZE - pos.nPos)) {
-            FILE* file = OpenUndoFile(pos);
-            if (file) {
-                LogPrintf("Pre-allocating up to position 0x%x in rev%05u.dat\n", nNewChunks * UNDOFILE_CHUNK_SIZE, pos.nFile);
-                AllocateFileRange(file, pos.nPos, nNewChunks * UNDOFILE_CHUNK_SIZE - pos.nPos);
-                fclose(file);
-            }
-        } else
-            return state.Error("out of disk space");
-    }
-
-    return true;
-}
-
 bool CheckBlock(const CBlock& block, CValidationState& state, bool fCheckMerkleRoot)
 {
     // These are checks that are independent of context.

From 4c491ecdb4ffb2645fa758c6d0d780c4cf8cfd38 Mon Sep 17 00:00:00 2001
From: Daniel Kraft <d@domob.eu>
Date: Wed, 7 Apr 2021 14:20:40 +0200
Subject: [PATCH 2/9] Clean up some mn config code.

This is a bunch of related and straight-forward cleanups to the code
around masternode configuration:  Pass arguments as const& instead of
by value, mark functions as const, and move helper functions from
being static in a class and declared inside the header to just being
inside an anonymous namespace in the cpp file.
---
 divi/src/MasternodeBroadcastFactory.cpp | 35 ++++++++-------
 divi/src/MasternodeBroadcastFactory.h   | 60 +++++++------------------
 divi/src/masternode-sync.h              |  2 +-
 divi/src/masternode.cpp                 |  5 ++-
 divi/src/masternode.h                   | 16 ++++---
 divi/src/masternodeconfig.cpp           | 12 ++---
 divi/src/masternodeconfig.h             |  9 ++--
 7 files changed, 63 insertions(+), 76 deletions(-)

diff --git a/divi/src/MasternodeBroadcastFactory.cpp b/divi/src/MasternodeBroadcastFactory.cpp
index fac4d3730..7207e8863 100644
--- a/divi/src/MasternodeBroadcastFactory.cpp
+++ b/divi/src/MasternodeBroadcastFactory.cpp
@@ -17,7 +17,10 @@ extern CChain chainActive;
 extern bool fReindex;
 extern bool fImporting;
 
-bool CMasternodeBroadcastFactory::checkBlockchainSync(std::string& strErrorRet, bool fOffline)
+namespace
+{
+
+bool checkBlockchainSync(std::string& strErrorRet, bool fOffline)
 {
      if (!fOffline && !IsBlockchainSynced()) {
         strErrorRet = "Sync in progress. Must wait until sync is complete to start Masternode";
@@ -26,7 +29,7 @@ bool CMasternodeBroadcastFactory::checkBlockchainSync(std::string& strErrorRet,
     }
     return true;
 }
-bool CMasternodeBroadcastFactory::setMasternodeKeys(
+bool setMasternodeKeys(
     const std::string& strKeyMasternode,
     std::pair<CKey,CPubKey>& masternodeKeyPair,
     std::string& strErrorRet)
@@ -38,7 +41,7 @@ bool CMasternodeBroadcastFactory::setMasternodeKeys(
     }
     return true;
 }
-bool CMasternodeBroadcastFactory::setMasternodeCollateralKeys(
+bool setMasternodeCollateralKeys(
     const std::string& txHash,
     const std::string& outputIndex,
     const std::string& service,
@@ -63,7 +66,7 @@ bool CMasternodeBroadcastFactory::setMasternodeCollateralKeys(
     return true;
 }
 
-bool CMasternodeBroadcastFactory::checkMasternodeCollateral(
+bool checkMasternodeCollateral(
     const CTxIn& txin,
     const std::string& txHash,
     const std::string& outputIndex,
@@ -95,7 +98,7 @@ bool CMasternodeBroadcastFactory::checkMasternodeCollateral(
     return true;
 }
 
-bool CMasternodeBroadcastFactory::createArgumentsFromConfig(
+bool createArgumentsFromConfig(
     const CMasternodeConfig::CMasternodeEntry configEntry,
     std::string& strErrorRet,
     bool fOffline,
@@ -121,6 +124,8 @@ bool CMasternodeBroadcastFactory::createArgumentsFromConfig(
     return true;
 }
 
+} // anonymous namespace
+
 bool CMasternodeBroadcastFactory::Create(
     const CMasternodeConfig::CMasternodeEntry configEntry,
     CPubKey pubkeyCollateralAddress,
@@ -278,10 +283,10 @@ CMasternodePing createDelayedMasternodePing(const CMasternodeBroadcast& mnb)
 } // anonymous namespace
 
 void CMasternodeBroadcastFactory::createWithoutSignatures(
-    CTxIn txin,
-    CService service,
-    CPubKey pubKeyCollateralAddressNew,
-    CPubKey pubKeyMasternodeNew,
+    const CTxIn& txin,
+    const CService& service,
+    const CPubKey& pubKeyCollateralAddressNew,
+    const CPubKey& pubKeyMasternodeNew,
     const MasternodeTier nMasternodeTier,
     bool deferRelay,
     CMasternodeBroadcast& mnbRet)
@@ -299,12 +304,12 @@ void CMasternodeBroadcastFactory::createWithoutSignatures(
 }
 
 bool CMasternodeBroadcastFactory::Create(
-    CTxIn txin,
-    CService service,
-    CKey keyCollateralAddressNew,
-    CPubKey pubKeyCollateralAddressNew,
-    CKey keyMasternodeNew,
-    CPubKey pubKeyMasternodeNew,
+    const CTxIn& txin,
+    const CService& service,
+    const CKey& keyCollateralAddressNew,
+    const CPubKey& pubKeyCollateralAddressNew,
+    const CKey& keyMasternodeNew,
+    const CPubKey& pubKeyMasternodeNew,
     const MasternodeTier nMasternodeTier,
     std::string& strErrorRet,
     CMasternodeBroadcast& mnbRet,
diff --git a/divi/src/MasternodeBroadcastFactory.h b/divi/src/MasternodeBroadcastFactory.h
index e7edd478a..2f576f060 100644
--- a/divi/src/MasternodeBroadcastFactory.h
+++ b/divi/src/MasternodeBroadcastFactory.h
@@ -37,10 +37,10 @@ class CMasternodeBroadcastFactory
         std::string& strErrorRet);
 private:
     static void createWithoutSignatures(
-        CTxIn txin,
-        CService service,
-        CPubKey pubKeyCollateralAddressNew,
-        CPubKey pubKeyMasternodeNew,
+        const CTxIn& txin,
+        const CService& service,
+        const CPubKey& pubKeyCollateralAddressNew,
+        const CPubKey& pubKeyMasternodeNew,
         MasternodeTier nMasternodeTier,
         bool deferRelay,
         CMasternodeBroadcast& mnbRet);
@@ -57,45 +57,15 @@ class CMasternodeBroadcastFactory
         CMasternodeBroadcast& mnb,
         std::string& strErrorRet);
 
-    static bool Create(CTxIn vin,
-                        CService service,
-                        CKey keyCollateralAddressNew,
-                        CPubKey pubKeyCollateralAddressNew,
-                        CKey keyMasternodeNew,
-                        CPubKey pubKeyMasternodeNew,
-                        MasternodeTier nMasternodeTier,
-                        std::string& strErrorRet,
-                        CMasternodeBroadcast& mnbRet,
-                        bool deferRelay);
-    static bool checkBlockchainSync(
-        std::string& strErrorRet, bool fOffline);
-    static bool setMasternodeKeys(
-        const std::string& strKeyMasternode,
-        std::pair<CKey,CPubKey>& masternodeKeyPair,
-        std::string& strErrorRet);
-    static bool setMasternodeCollateralKeys(
-        const std::string& txHash,
-        const std::string& outputIndex,
-        const std::string& service,
-        bool collateralPrivKeyIsRemote,
-        CTxIn& txin,
-        std::pair<CKey,CPubKey>& masternodeCollateralKeyPair,
-        std::string& error);
-    static bool checkMasternodeCollateral(
-        const CTxIn& txin,
-        const std::string& txHash,
-        const std::string& outputIndex,
-        const std::string& service,
-        MasternodeTier& nMasternodeTier,
-        std::string& strErrorRet);
-    static bool createArgumentsFromConfig(
-        const CMasternodeConfig::CMasternodeEntry configEntry,
-        std::string& strErrorRet,
-        bool fOffline,
-        bool collateralPrivKeyIsRemote,
-        CTxIn& txin,
-        std::pair<CKey,CPubKey>& masternodeKeyPair,
-        std::pair<CKey,CPubKey>& masternodeCollateralKeyPair,
-        MasternodeTier& nMasternodeTier);
+    static bool Create(const CTxIn& vin,
+                       const CService& service,
+                       const CKey& keyCollateralAddressNew,
+                       const CPubKey& pubKeyCollateralAddressNew,
+                       const CKey& keyMasternodeNew,
+                       const CPubKey& pubKeyMasternodeNew,
+                       MasternodeTier nMasternodeTier,
+                       std::string& strErrorRet,
+                       CMasternodeBroadcast& mnbRet,
+                       bool deferRelay);
 };
-#endif //MASTERNODE_BROADCAST_FACTORY_H
\ No newline at end of file
+#endif //MASTERNODE_BROADCAST_FACTORY_H
diff --git a/divi/src/masternode-sync.h b/divi/src/masternode-sync.h
index 1ce4a3b33..c15d852e1 100644
--- a/divi/src/masternode-sync.h
+++ b/divi/src/masternode-sync.h
@@ -85,7 +85,7 @@ class CMasternodeSync
     bool MasternodeWinnersListIsSync(CNode* pnode, const int64_t now);
     void Process(bool networkIsRegtest);
     bool IsSynced() const;
-    bool IsMasternodeListSynced() { return RequestedMasternodeAssets > MASTERNODE_SYNC_LIST; }
+    bool IsMasternodeListSynced() const { return RequestedMasternodeAssets > MASTERNODE_SYNC_LIST; }
     void AskForMN(CNode* pnode, const CTxIn& vin) const;
 };
 
diff --git a/divi/src/masternode.cpp b/divi/src/masternode.cpp
index d2391d2c2..cf457f42b 100644
--- a/divi/src/masternode.cpp
+++ b/divi/src/masternode.cpp
@@ -258,7 +258,10 @@ bool CMasternode::IsValidNetAddr() const
             (IsReachable(addr) && addr.IsRoutable());
 }
 
-CMasternodeBroadcast::CMasternodeBroadcast(CService newAddr, CTxIn newVin, CPubKey pubKeyCollateralAddressNew, CPubKey pubKeyMasternodeNew, const MasternodeTier nMasternodeTier, int protocolVersionIn)
+CMasternodeBroadcast::CMasternodeBroadcast(
+    const CService& newAddr, const CTxIn& newVin,
+    const CPubKey& pubKeyCollateralAddressNew, const CPubKey& pubKeyMasternodeNew,
+    const MasternodeTier nMasternodeTier, const int protocolVersionIn)
 {
     vin = newVin;
     addr = newAddr;
diff --git a/divi/src/masternode.h b/divi/src/masternode.h
index f987234c1..b561097fc 100644
--- a/divi/src/masternode.h
+++ b/divi/src/masternode.h
@@ -146,15 +146,19 @@ class CMasternode
 
 class CMasternodeBroadcast : public CMasternode
 {
-public:
-    CMasternodeBroadcast() = default;
+private:
     CMasternodeBroadcast(
-        CService newAddr,
-        CTxIn newVin,
-        CPubKey pubKeyCollateralAddress,
-        CPubKey pubKeyMasternode,
+        const CService& newAddr,
+        const CTxIn& newVin,
+        const CPubKey& pubKeyCollateralAddress,
+        const CPubKey& pubKeyMasternode,
         MasternodeTier nMasternodeTier,
         int protocolVersionIn);
+
+    friend class CMasternodeBroadcastFactory;
+
+public:
+    CMasternodeBroadcast() = default;
     CMasternodeBroadcast(const CMasternode& mn);
 
     void Relay() const;
diff --git a/divi/src/masternodeconfig.cpp b/divi/src/masternodeconfig.cpp
index 91b9debb9..c48f8304d 100644
--- a/divi/src/masternodeconfig.cpp
+++ b/divi/src/masternodeconfig.cpp
@@ -23,10 +23,11 @@ boost::filesystem::path GetMasternodeConfigFile()
     if (!pathConfigFile.is_complete()) pathConfigFile = GetDataDir() / pathConfigFile;
     return pathConfigFile;
 }
-void CMasternodeConfig::add(std::string alias, std::string ip, std::string privKey, std::string txHash, std::string outputIndex)
+
+void CMasternodeConfig::add(const std::string& alias, const std::string& ip, const std::string& privKey,
+                            const std::string& txHash, const std::string& outputIndex)
 {
-    CMasternodeEntry cme(alias, ip, privKey, txHash, outputIndex);
-    entries.push_back(cme);
+    entries.emplace_back(alias, ip, privKey, txHash, outputIndex);
 }
 
 bool CMasternodeConfig::read(std::string& strErr)
@@ -94,15 +95,16 @@ CMasternodeConfig::CMasternodeConfig()
 {
     entries = std::vector<CMasternodeEntry>();
 }
+
 const std::vector<CMasternodeConfig::CMasternodeEntry>& CMasternodeConfig::getEntries() const
 {
     return entries;
 }
 
-int CMasternodeConfig::getCount()
+int CMasternodeConfig::getCount() const
 {
     int c = -1;
-    BOOST_FOREACH (CMasternodeEntry e, entries) {
+    for (const auto& e : entries) {
         if (e.getAlias() != "") c++;
     }
     return c;
diff --git a/divi/src/masternodeconfig.h b/divi/src/masternodeconfig.h
index d5ac185d9..2d34edb4a 100644
--- a/divi/src/masternodeconfig.h
+++ b/divi/src/masternodeconfig.h
@@ -25,7 +25,9 @@ class CMasternodeConfig
         std::string outputIndex;
 
     public:
-        CMasternodeEntry(std::string alias, std::string ip, std::string privKey, std::string txHash, std::string outputIndex)
+        CMasternodeEntry(const std::string& alias, const std::string& ip,
+                         const std::string& privKey,
+                         const std::string& txHash, const std::string& outputIndex)
         {
             this->alias = alias;
             this->ip = ip;
@@ -91,9 +93,10 @@ class CMasternodeConfig
 
     void clear();
     bool read(std::string& strErr);
-    void add(std::string alias, std::string ip, std::string privKey, std::string txHash, std::string outputIndex);
+    void add(const std::string& alias, const std::string& ip, const std::string& privKey,
+             const std::string& txHash, const std::string& outputIndex);
     const std::vector<CMasternodeEntry>& getEntries() const;
-    int getCount();
+    int getCount() const;
 
 private:
     std::vector<CMasternodeEntry> entries;

From 6803639c9aaebdf8e3311a066e1905c9cc6b7faf Mon Sep 17 00:00:00 2001
From: Daniel Kraft <d@domob.eu>
Date: Thu, 8 Oct 2020 15:56:35 +0200
Subject: [PATCH 3/9] Introduce rewardScript for masternodes.

This adds a new field, CScript rewardScript, to the masternode data
structures.  For now, we just add it, return it from the RPCs, and
set it to the script corresponding to the collateral pubkey on
creation.

We also serialise the new field as part of CMasternode, which is used
e.g. in the on-disk cache, but not the wire protocol (where
CMasternodeBroadcast is used instead).  Thus this change invalidates the
mncache format, but has no other effects on compatibility.

In the future, we will implement a protocol upgrade and also network
fork that will use this new field so masternodes can specify an arbitrary
script to which they want to receive their payments, rather than being
paid always to the collateral address.
---
 divi/src/MasternodeModule.cpp |  2 ++
 divi/src/MasternodeModule.h   |  6 +++++-
 divi/src/masternode.cpp       | 10 +++++++++-
 divi/src/masternode.h         | 17 +++++++++++++++++
 divi/src/masternodeman.cpp    |  1 +
 divi/src/rpcmasternode.cpp    |  4 +++-
 6 files changed, 37 insertions(+), 3 deletions(-)

diff --git a/divi/src/MasternodeModule.cpp b/divi/src/MasternodeModule.cpp
index 118e979ec..1e29011a4 100644
--- a/divi/src/MasternodeModule.cpp
+++ b/divi/src/MasternodeModule.cpp
@@ -241,6 +241,7 @@ std::vector<MasternodeListEntry> GetMasternodeList(std::string strFilter)
         entry.outputIndex = oIdx;
         entry.status = strStatus;
         entry.collateralAddress = CBitcoinAddress(masternode.pubKeyCollateralAddress.GetID()).ToString();
+        entry.rewardScript = HexStr(masternode.rewardScript);
         entry.protocolVersion = masternode.protocolVersion;
         entry.lastSeenTime = (int64_t)masternode.lastPing.sigTime;
         entry.activeTime = (int64_t)(masternode.lastPing.sigTime - masternode.sigTime);
@@ -262,6 +263,7 @@ ActiveMasternodeStatus GetActiveMasternodeStatus()
         result.outputIndex = std::to_string(activeMasternode.vin.prevout.n);
         result.netAddress = activeMasternode.service.ToString();
         result.collateralAddress = CBitcoinAddress(pmn->pubKeyCollateralAddress.GetID()).ToString();
+        result.rewardScript = HexStr(pmn->rewardScript);
         result.statusCode = std::to_string(activeMasternode.status);
         result.statusMessage = activeMasternode.GetStatus();
         result.activeMasternodeFound = true;
diff --git a/divi/src/MasternodeModule.h b/divi/src/MasternodeModule.h
index 787871d21..98f7819e3 100644
--- a/divi/src/MasternodeModule.h
+++ b/divi/src/MasternodeModule.h
@@ -46,6 +46,7 @@ struct ActiveMasternodeStatus
     std::string outputIndex;
     std::string netAddress;
     std::string collateralAddress;
+    std::string rewardScript;
     std::string statusCode;
     std::string statusMessage;
     ActiveMasternodeStatus(
@@ -54,6 +55,7 @@ struct ActiveMasternodeStatus
         , outputIndex()
         , netAddress()
         , collateralAddress()
+        , rewardScript()
         , statusCode()
         , statusMessage()
     {}
@@ -66,6 +68,7 @@ struct MasternodeListEntry
     uint64_t outputIndex;
     std::string status;
     std::string collateralAddress;
+    std::string rewardScript;
     int protocolVersion;
     int64_t signatureTime;
     int64_t lastSeenTime;
@@ -78,6 +81,7 @@ struct MasternodeListEntry
         , outputIndex()
         , status()
         , collateralAddress()
+        , rewardScript()
         , protocolVersion()
         , signatureTime()
         , lastSeenTime()
@@ -104,4 +108,4 @@ bool LoadMasternodeDataFromDisk(UIMessenger& uiMessenger,std::string pathToDataD
 void DumpMasternodeDataToDisk();
 CMasternodePayments& GetMasternodePayments();
 bool InitializeMasternodeIfRequested(const Settings& settings, bool transactionIndexEnabled, std::string& errorMessage);
-#endif //MASTERNODE_MODULE_H
\ No newline at end of file
+#endif //MASTERNODE_MODULE_H
diff --git a/divi/src/masternode.cpp b/divi/src/masternode.cpp
index cf457f42b..a50469c15 100644
--- a/divi/src/masternode.cpp
+++ b/divi/src/masternode.cpp
@@ -6,7 +6,6 @@
 #include "masternode.h"
 
 #include <sync.h>
-#include <Logging.h>
 #include <boost/lexical_cast.hpp>
 #include <timedata.h>
 #include <script/standard.h>
@@ -63,6 +62,7 @@ CMasternode::CMasternode(const CMasternode& other)
     vin = other.vin;
     addr = other.addr;
     pubKeyCollateralAddress = other.pubKeyCollateralAddress;
+    rewardScript = other.rewardScript;
     pubKeyMasternode = other.pubKeyMasternode;
     signature = other.signature;
     activeState = other.activeState;
@@ -84,6 +84,7 @@ CMasternode::CMasternode(const CMasternodeBroadcast& mnb)
     vin = mnb.vin;
     addr = mnb.addr;
     pubKeyCollateralAddress = mnb.pubKeyCollateralAddress;
+    rewardScript = mnb.rewardScript;
     pubKeyMasternode = mnb.pubKeyMasternode;
     signature = mnb.signature;
     activeState = MASTERNODE_ENABLED;
@@ -109,6 +110,7 @@ void CMasternode::swap(CMasternode& first, CMasternode& second) // nothrow
     swap(first.vin, second.vin);
     swap(first.addr, second.addr);
     swap(first.pubKeyCollateralAddress, second.pubKeyCollateralAddress);
+    swap(first.rewardScript, second.rewardScript);
     swap(first.pubKeyMasternode, second.pubKeyMasternode);
     swap(first.signature, second.signature);
     swap(first.activeState, second.activeState);
@@ -128,6 +130,11 @@ CMasternode& CMasternode::operator=(CMasternode from)
     return *this;
 }
 
+CScript CMasternode::GetDefaultRewardScript() const
+{
+    return GetScriptForDestination(pubKeyCollateralAddress.GetID());
+}
+
 bool CMasternode::IsEnabled() const
 {
     return activeState == MASTERNODE_ENABLED;
@@ -266,6 +273,7 @@ CMasternodeBroadcast::CMasternodeBroadcast(
     vin = newVin;
     addr = newAddr;
     pubKeyCollateralAddress = pubKeyCollateralAddressNew;
+    rewardScript = GetDefaultRewardScript();
     pubKeyMasternode = pubKeyMasternodeNew;
     protocolVersion = protocolVersionIn;
     nTier = nMasternodeTier;
diff --git a/divi/src/masternode.h b/divi/src/masternode.h
index b561097fc..fe9dedd8b 100644
--- a/divi/src/masternode.h
+++ b/divi/src/masternode.h
@@ -12,6 +12,7 @@
 #include <primitives/transaction.h>
 #include <masternode-tier.h>
 #include <MasternodePing.h>
+#include <Logging.h>
 
 #define MASTERNODE_MIN_CONFIRMATIONS 15
 #define MASTERNODE_MIN_MNP_SECONDS (10 * 60)
@@ -59,6 +60,10 @@ class CMasternode
     CTxIn vin;
     CService addr;
     CPubKey pubKeyCollateralAddress;
+    /** The script to which masternode rewards should be paid.  This often
+     *  is the collateral address, but (starting at some fork point) masternodes
+     *  can also choose a different script.  */
+    CScript rewardScript;
     CPubKey pubKeyMasternode;
     std::vector<unsigned char> signature;
     int activeState;
@@ -90,6 +95,10 @@ class CMasternode
         return !(a.vin == b.vin);
     }
 
+    /** Returns the "default" reward script, which is the one
+     *  matching the collateral address.  */
+    CScript GetDefaultRewardScript() const;
+
     /** Calculates the score of the current masternode, based on the given
      *  seed hash.  It should be the result of GetBlockHashForScoring of
      *  the target block height.  */
@@ -119,6 +128,7 @@ class CMasternode
         READWRITE(vin);
         READWRITE(addr);
         READWRITE(pubKeyCollateralAddress);
+        READWRITE(rewardScript);
         READWRITE(pubKeyMasternode);
         READWRITE(signature);
         READWRITE(sigTime);
@@ -173,6 +183,13 @@ class CMasternodeBroadcast : public CMasternode
         READWRITE(vin);
         READWRITE(addr);
         READWRITE(pubKeyCollateralAddress);
+        /* The wire format (for which the serialisation here is relevant)
+           does not include the reward script yet.  */
+        if (ser_action.ForRead()) {
+            rewardScript = GetDefaultRewardScript();
+        } else if (rewardScript != GetDefaultRewardScript()) {
+            LogPrintf("WARNING: CMasternodeBroadcast - ignoring changed reward script for serialisation of %s\n", vin.prevout.ToString());
+        }
         READWRITE(pubKeyMasternode);
         READWRITE(signature);
         READWRITE(sigTime);
diff --git a/divi/src/masternodeman.cpp b/divi/src/masternodeman.cpp
index e2e6485bb..91eaa992a 100644
--- a/divi/src/masternodeman.cpp
+++ b/divi/src/masternodeman.cpp
@@ -204,6 +204,7 @@ bool CMasternodeMan::UpdateWithNewBroadcast(const CMasternodeBroadcast &mnb, CMa
     if (mnb.sigTime > masternode.sigTime) {
         masternode.pubKeyMasternode = mnb.pubKeyMasternode;
         masternode.pubKeyCollateralAddress = mnb.pubKeyCollateralAddress;
+        masternode.rewardScript = mnb.rewardScript;
         masternode.sigTime = mnb.sigTime;
         masternode.signature = mnb.signature;
         masternode.protocolVersion = mnb.protocolVersion;
diff --git a/divi/src/rpcmasternode.cpp b/divi/src/rpcmasternode.cpp
index be6621964..64d2b12a0 100644
--- a/divi/src/rpcmasternode.cpp
+++ b/divi/src/rpcmasternode.cpp
@@ -353,12 +353,13 @@ Value listmasternodes(const Array& params, bool fHelp)
     for(auto& masternodeEntry : masternodeList)
     {
         Object obj;
-        obj.reserve(10);
+        obj.reserve(11);
         obj.emplace_back("network", masternodeEntry.network);
         obj.emplace_back("txhash", masternodeEntry.txHash);
         obj.emplace_back("outidx", masternodeEntry.outputIndex);
         obj.emplace_back("status", masternodeEntry.status);
         obj.emplace_back("addr", masternodeEntry.collateralAddress);
+        obj.emplace_back("rewardscript", masternodeEntry.rewardScript);
         obj.emplace_back("version", masternodeEntry.protocolVersion);
         obj.emplace_back("lastseen", masternodeEntry.lastSeenTime);
         obj.emplace_back("activetime", masternodeEntry.activeTime);
@@ -541,6 +542,7 @@ Value getmasternodestatus (const Array& params, bool fHelp)
     mnObj.push_back(Pair("outputidx", (uint64_t)std::stoi(activeMNStatus.outputIndex) ));
     mnObj.push_back(Pair("netaddr", activeMNStatus.netAddress));
     mnObj.push_back(Pair("addr", activeMNStatus.collateralAddress));
+    mnObj.push_back(Pair("rewardscript", activeMNStatus.rewardScript));
     mnObj.push_back(Pair("status", std::stoi(activeMNStatus.statusCode) ));
     mnObj.push_back(Pair("message", activeMNStatus.statusMessage));
     return mnObj;

From 9a7397383ae9abb6cbfcfb114ef4fa3a2df3664c Mon Sep 17 00:00:00 2001
From: Daniel Kraft <d@domob.eu>
Date: Fri, 9 Oct 2020 14:31:52 +0200
Subject: [PATCH 4/9] New wire protocol for reward script.

Define a new wire protocol version, and for peers that match the
version, send the reward script as explicit part of the masternode
broadcast messages.

Also, if the reward script is not the default value, include it in the
signature message of the broadcast (so that the field is authenticated
by the collateral signature).

Until the protocol version is bumped on the network (which is not yet
the case with this commit), masternodes with non-default reward script
will not be accepted as valid.
---
 divi/qa/rpc-tests/mnoperation.py |  5 +++--
 divi/src/masternode.cpp          | 26 +++++++++++++++++++++++---
 divi/src/masternode.h            | 14 ++++++++------
 divi/src/masternodeman.cpp       |  6 ++++++
 divi/src/version-util.cpp        |  2 +-
 divi/src/version.h               |  3 +++
 6 files changed, 44 insertions(+), 12 deletions(-)

diff --git a/divi/qa/rpc-tests/mnoperation.py b/divi/qa/rpc-tests/mnoperation.py
index 57ccf0b47..ba0b9b883 100755
--- a/divi/qa/rpc-tests/mnoperation.py
+++ b/divi/qa/rpc-tests/mnoperation.py
@@ -187,8 +187,9 @@ def start_masternodes (self):
     assert_equal (lst[1]["tier"], "SILVER")
     for i in range (2):
       assert_equal (lst[i]["status"], "ENABLED")
-      assert_equal (lst[i]["addr"],
-                    self.nodes[i + 1].getmasternodestatus ()["addr"])
+      n = self.nodes[i + 1]
+      for key in ["addr", "rewardscript"]:
+        assert_equal (lst[i][key], n.getmasternodestatus ()[key])
       assert_equal (lst[i]["txhash"], self.cfg[i].txid)
       assert_equal (lst[i]["outidx"], self.cfg[i].vout)
 
diff --git a/divi/src/masternode.cpp b/divi/src/masternode.cpp
index a50469c15..4da9711c2 100644
--- a/divi/src/masternode.cpp
+++ b/divi/src/masternode.cpp
@@ -11,6 +11,8 @@
 #include <script/standard.h>
 #include <chainparams.h>
 
+#include <sstream>
+
 CAmount CMasternode::GetTierCollateralAmount(const MasternodeTier tier)
 {
     const auto& collateralMap = Params().MasternodeCollateralMap();
@@ -291,10 +293,28 @@ void CMasternodeBroadcast::Relay() const
 
 std::string CMasternodeBroadcast::getMessageToSign() const
 {
-    std::string vchPubKey(pubKeyCollateralAddress.begin(), pubKeyCollateralAddress.end());
-    std::string vchPubKey2(pubKeyMasternode.begin(), pubKeyMasternode.end());
+    std::ostringstream message;
+
+    message << addr.ToString();
+    message << sigTime;
+    message << std::string(pubKeyCollateralAddress.begin(), pubKeyCollateralAddress.end());
+
+    /* The signature must commit also to the reward script.  We do this by
+       including it in the signed message if and only if it does not match
+       the collateral address.  This makes sure that the signature format
+       is backwards compatible for situations where we just have the
+       default reward script.  */
+    if (rewardScript != GetDefaultRewardScript()) {
+        /* Include a "marker", so that e.g. a zero-length script is different
+           from the default situation.  */
+        message << "rs";
+        message << std::string(rewardScript.begin(), rewardScript.end());
+    }
+
+    message << std::string(pubKeyMasternode.begin(), pubKeyMasternode.end());
+    message << protocolVersion;
 
-    return addr.ToString() + boost::lexical_cast<std::string>(sigTime) + vchPubKey + vchPubKey2 + boost::lexical_cast<std::string>(protocolVersion);
+    return message.str();
 }
 
 uint256 CMasternodeBroadcast::GetHash() const
diff --git a/divi/src/masternode.h b/divi/src/masternode.h
index fe9dedd8b..577a3a47e 100644
--- a/divi/src/masternode.h
+++ b/divi/src/masternode.h
@@ -183,12 +183,14 @@ class CMasternodeBroadcast : public CMasternode
         READWRITE(vin);
         READWRITE(addr);
         READWRITE(pubKeyCollateralAddress);
-        /* The wire format (for which the serialisation here is relevant)
-           does not include the reward script yet.  */
-        if (ser_action.ForRead()) {
-            rewardScript = GetDefaultRewardScript();
-        } else if (rewardScript != GetDefaultRewardScript()) {
-            LogPrintf("WARNING: CMasternodeBroadcast - ignoring changed reward script for serialisation of %s\n", vin.prevout.ToString());
+        if (nVersion >= MN_REWARD_SCRIPT_VERSION) {
+            READWRITE(rewardScript);
+        } else {
+            if (ser_action.ForRead()) {
+                rewardScript = GetDefaultRewardScript();
+            } else if (rewardScript != GetDefaultRewardScript()) {
+                LogPrintf("WARNING: CMasternodeBroadcast - ignoring changed reward script for serialisation of %s\n", vin.prevout.ToString());
+            }
         }
         READWRITE(pubKeyMasternode);
         READWRITE(signature);
diff --git a/divi/src/masternodeman.cpp b/divi/src/masternodeman.cpp
index 91eaa992a..7d50594c5 100644
--- a/divi/src/masternodeman.cpp
+++ b/divi/src/masternodeman.cpp
@@ -250,6 +250,12 @@ bool CMasternodeMan::CheckInputsForMasternode(const CMasternodeBroadcast& mnb, i
 }
 bool CMasternodeMan::CheckAndUpdateMasternode(CMasternodeSync& masternodeSynchronization, CMasternodeBroadcast& mnb, int& nDoS)
 {
+    /* Until the protocol is updated, do not allow custom reward scripts.  */
+    if (ActiveProtocol() < MN_REWARD_SCRIPT_VERSION && mnb.rewardScript != mnb.GetDefaultRewardScript()) {
+        LogPrintf("%s : mnb - reward script does not match collateral address for %s\n", __func__, mnb.vin.prevout.ToString());
+        return false;
+    }
+
     // make sure signature isn't in the future (past is OK)
     if (mnb.sigTime > GetAdjustedTime() + 60 * 60) {
         LogPrintf("%s : mnb - Signature rejected, too far into the future %s\n", __func__, mnb.vin.prevout.hash.ToString());
diff --git a/divi/src/version-util.cpp b/divi/src/version-util.cpp
index f1fb453f9..13c4c8522 100644
--- a/divi/src/version-util.cpp
+++ b/divi/src/version-util.cpp
@@ -2,7 +2,7 @@
 
 #include <Logging.h>
 
-static int version = MIN_PEER_PROTO_VERSION_AFTER_ENFORCEMENT;
+static int version = MN_REWARD_SCRIPT_VERSION;
 const int& PROTOCOL_VERSION(version);
 
 void SetProtocolVersion(const int newVersion)
diff --git a/divi/src/version.h b/divi/src/version.h
index f85f41a05..9079f8253 100644
--- a/divi/src/version.h
+++ b/divi/src/version.h
@@ -33,6 +33,9 @@ static constexpr int MEMPOOL_GD_VERSION = 60002;
 //! "filter*" commands are disabled without NODE_BLOOM after and including this version
 static constexpr int NO_BLOOM_VERSION = 70005;
 
+//! include explicit reward script in masternode broadcasts
+static constexpr int MN_REWARD_SCRIPT_VERSION = 71000;
+
 /** The current protocol version.   Since it can be changed through -protocolversion
  *  for testing, it is not a constexpr but a real variable.  */
 extern const int& PROTOCOL_VERSION;

From fb01cc2ae946e3d4013ee03e6da56c443f4505ff Mon Sep 17 00:00:00 2001
From: Daniel Kraft <d@domob.eu>
Date: Mon, 12 Oct 2020 16:42:15 +0200
Subject: [PATCH 5/9] Pay to reward script of masternodes.

Instead of using the collateral pubkey, pay to the declared reward
script of masternodes (and use that to check payments).
---
 divi/src/masternode-payments.cpp | 35 +++++++++++++++++++-------------
 divi/src/masternode.cpp          |  3 +--
 divi/src/version.cpp             |  4 ++++
 3 files changed, 26 insertions(+), 16 deletions(-)

diff --git a/divi/src/masternode-payments.cpp b/divi/src/masternode-payments.cpp
index d3945b493..f231e5329 100644
--- a/divi/src/masternode-payments.cpp
+++ b/divi/src/masternode-payments.cpp
@@ -362,9 +362,7 @@ bool CMasternodePayments::CheckMasternodeWinnerValidity(const CMasternodeSync& m
     /* Make sure that the payee is in our own payment queue near the top.  */
     const std::vector<CMasternode*> mnQueue = GetMasternodePaymentQueue(seedHash, winner.GetHeight());
     for (int i = 0; i < std::min<int>(2 * MNPAYMENTS_SIGNATURES_TOTAL, mnQueue.size()); ++i) {
-        const auto& mn = *mnQueue[i];
-        const CScript mnPayee = GetScriptForDestination(mn.pubKeyCollateralAddress.GetID());
-        if (mnPayee == winner.payee)
+        if (winner.payee == mnQueue[i]->GetPaymentScript())
             return true;
     }
     return false;
@@ -474,21 +472,31 @@ std::string CMasternodeBlockPayees::GetRequiredPaymentsString() const
 {
     LOCK(cs_vecPayments);
 
-    std::string ret = "Unknown";
+    std::ostringstream ret;
+    bool found = false;
 
     for (const auto& payee : vecPayments) {
-        CTxDestination address1;
-        ExtractDestination(payee.scriptPubKey, address1);
-        CBitcoinAddress address2(address1);
+        std::string thisPayee;
 
-        if (ret != "Unknown") {
-            ret += ", " + address2.ToString() + ":" + boost::lexical_cast<std::string>(payee.nVotes);
+        CTxDestination address1;
+        if (ExtractDestination(payee.scriptPubKey, address1)) {
+            const CBitcoinAddress address2(address1);
+            thisPayee = address2.ToString();
         } else {
-            ret = address2.ToString() + ":" + boost::lexical_cast<std::string>(payee.nVotes);
+            thisPayee = HexStr(payee.scriptPubKey);
         }
+
+        if (found)
+            ret << ", ";
+
+        found = true;
+        ret << thisPayee << ":" << payee.nVotes;
     }
 
-    return ret;
+    if (!found)
+        return "Unknown";
+
+    return ret.str();
 }
 
 std::string CMasternodePayments::GetRequiredPaymentsString(const uint256& seedHash) const
@@ -584,7 +592,6 @@ unsigned CMasternodePayments::FindLastPayeePaymentTime(const CMasternode& master
     const CBlockIndex* chainTip = chainActive.Tip();
     if (chainTip == NULL) return 0u;
 
-    CScript mnPayee = GetScriptForDestination(masternode.pubKeyCollateralAddress.GetID());
     unsigned n = 0;
     for (unsigned int i = 1; chainTip && chainTip->nHeight > 0; i++) {
         if (n >= maxBlockDepth) {
@@ -602,7 +609,7 @@ unsigned CMasternodePayments::FindLastPayeePaymentTime(const CMasternode& master
                 Search for this payee, with at least 2 votes. This will aid in consensus allowing the network
                 to converge on the same payees quickly, then keep the same schedule.
             */
-            if (masternodePayees->HasPayeeWithVotes(mnPayee, 2)) {
+            if (masternodePayees->HasPayeeWithVotes(masternode.GetPaymentScript(), 2)) {
                 return chainTip->nTime + masternode.DeterministicTimeOffset();
             }
         }
@@ -656,7 +663,7 @@ void ComputeMasternodesAndScores(
         // proper testing with a very small number of masternodes (which would
         // be scheduled and skipped all the time).
         if (Params().NetworkID() != CBaseChainParams::REGTEST) {
-            if (masternodePayments.IsScheduled(GetScriptForDestination(mn.pubKeyCollateralAddress.GetID()), nBlockHeight)) continue;
+            if (masternodePayments.IsScheduled(mn.GetPaymentScript(), nBlockHeight)) continue;
         }
 
         //it's too new, wait for a cycle
diff --git a/divi/src/masternode.cpp b/divi/src/masternode.cpp
index 4da9711c2..2fbb6f8b5 100644
--- a/divi/src/masternode.cpp
+++ b/divi/src/masternode.cpp
@@ -157,8 +157,7 @@ std::string CMasternode::Status() const
 
 CScript CMasternode::GetPaymentScript() const
 {
-    const CTxDestination dest(pubKeyCollateralAddress.GetID());
-    return GetScriptForDestination(dest);
+    return rewardScript;
 }
 
 static uint256 CalculateScoreHelper(CHashWriter hashWritter, int round)
diff --git a/divi/src/version.cpp b/divi/src/version.cpp
index b4f3ebfd6..dac54f414 100644
--- a/divi/src/version.cpp
+++ b/divi/src/version.cpp
@@ -1,5 +1,6 @@
 #include <version.h>
 
+#include <chainparams.h>
 #include <Settings.h>
 
 extern Settings& settings;
@@ -13,5 +14,8 @@ int ActiveProtocol()
     if (settings.ParameterIsSet("-activeversion"))
         return settings.GetArg("-activeversion", 0);
 
+    if (Params().NetworkID() == CBaseChainParams::REGTEST)
+        return MN_REWARD_SCRIPT_VERSION;
+
     return MIN_PEER_PROTO_VERSION_AFTER_ENFORCEMENT;
 }

From c565650859a4ff12794200c9046016c01a2fab39 Mon Sep 17 00:00:00 2001
From: Daniel Kraft <d@domob.eu>
Date: Wed, 7 Apr 2021 14:21:23 +0200
Subject: [PATCH 6/9] Allow configuration of reward address.

Allow setting a non-default reward script for masternodes, by editing
the masternode.conf file explicitly.  The RPC setupmasternode will not
generate such configuration lines for now, and also "old" masternode.conf
files will remain valid (with the default script).
---
 divi/src/MasternodeBroadcastFactory.cpp  | 28 ++++++++++++++++++++++--
 divi/src/MasternodeBroadcastFactory.h    |  2 ++
 divi/src/masternode.cpp                  |  9 ++++++--
 divi/src/masternode.h                    |  2 ++
 divi/src/masternodeconfig.cpp            | 12 +++++++---
 divi/src/masternodeconfig.h              | 18 +++++++++++++--
 divi/src/rpcmasternode.cpp               |  2 +-
 divi/src/test/ActiveMasternode_tests.cpp |  4 ++--
 8 files changed, 65 insertions(+), 12 deletions(-)

diff --git a/divi/src/MasternodeBroadcastFactory.cpp b/divi/src/MasternodeBroadcastFactory.cpp
index 7207e8863..4bc84412b 100644
--- a/divi/src/MasternodeBroadcastFactory.cpp
+++ b/divi/src/MasternodeBroadcastFactory.cpp
@@ -8,6 +8,7 @@
 #include <wallet.h>
 #include <chain.h>
 #include <base58address.h>
+#include <script/standard.h>
 #include <TransactionDiskAccessor.h>
 #include <timedata.h>
 #include <WalletTx.h>
@@ -105,6 +106,7 @@ bool createArgumentsFromConfig(
     bool collateralPrivKeyIsRemote,
     CTxIn& txin,
     std::pair<CKey,CPubKey>& masternodeKeyPair,
+    CScript& rewardScript,
     std::pair<CKey,CPubKey>& masternodeCollateralKeyPair,
     MasternodeTier& nMasternodeTier
     )
@@ -121,6 +123,18 @@ bool createArgumentsFromConfig(
     {
         return false;
     }
+
+    if (configEntry.getRewardAddress().empty())
+        rewardScript = CMasternode::GetDefaultRewardScript(masternodeCollateralKeyPair.second);
+    else {
+        const CBitcoinAddress addr(configEntry.getRewardAddress());
+        if (!addr.IsValid()) {
+            strErrorRet = strprintf("Invalid reward address for masternode: %s", configEntry.getRewardAddress());
+            return false;
+        }
+        rewardScript = GetScriptForDestination(addr.Get());
+    }
+
     return true;
 }
 
@@ -137,6 +151,7 @@ bool CMasternodeBroadcastFactory::Create(
     const bool deferRelay = true;
     CTxIn txin;
     std::pair<CKey,CPubKey> masternodeCollateralKeyPair;
+    CScript rewardScript;
     std::pair<CKey,CPubKey> masternodeKeyPair;
     MasternodeTier nMasternodeTier;
 
@@ -147,6 +162,7 @@ bool CMasternodeBroadcastFactory::Create(
         collateralPrivateKeyIsRemote,
         txin,
         masternodeKeyPair,
+        rewardScript,
         masternodeCollateralKeyPair,
         nMasternodeTier))
     {
@@ -157,6 +173,7 @@ bool CMasternodeBroadcastFactory::Create(
         txin,
         CService(configEntry.getIp()),
         pubkeyCollateralAddress,
+        rewardScript,
         masternodeKeyPair.second,
         nMasternodeTier,
         deferRelay,
@@ -185,6 +202,7 @@ bool CMasternodeBroadcastFactory::Create(
 
     CTxIn txin;
     std::pair<CKey,CPubKey> masternodeCollateralKeyPair;
+    CScript rewardScript;
     std::pair<CKey,CPubKey> masternodeKeyPair;
     MasternodeTier nMasternodeTier;
 
@@ -195,6 +213,7 @@ bool CMasternodeBroadcastFactory::Create(
         collateralPrivateKeyIsRemote,
         txin,
         masternodeKeyPair,
+        rewardScript,
         masternodeCollateralKeyPair,
         nMasternodeTier))
     {
@@ -205,6 +224,7 @@ bool CMasternodeBroadcastFactory::Create(
                 CService(strService),
                 masternodeCollateralKeyPair.first,
                 masternodeCollateralKeyPair.second,
+                rewardScript,
                 masternodeKeyPair.first,
                 masternodeKeyPair.second,
                 nMasternodeTier,
@@ -286,6 +306,7 @@ void CMasternodeBroadcastFactory::createWithoutSignatures(
     const CTxIn& txin,
     const CService& service,
     const CPubKey& pubKeyCollateralAddressNew,
+    const CScript& rewardScript,
     const CPubKey& pubKeyMasternodeNew,
     const MasternodeTier nMasternodeTier,
     bool deferRelay,
@@ -295,7 +316,9 @@ void CMasternodeBroadcastFactory::createWithoutSignatures(
              CBitcoinAddress(pubKeyCollateralAddressNew.GetID()).ToString(),
              pubKeyMasternodeNew.GetID().ToString());
 
-    mnbRet = CMasternodeBroadcast(service, txin, pubKeyCollateralAddressNew, pubKeyMasternodeNew, nMasternodeTier, PROTOCOL_VERSION);
+    mnbRet = CMasternodeBroadcast(service, txin,
+                                  pubKeyCollateralAddressNew, rewardScript, pubKeyMasternodeNew,
+                                  nMasternodeTier, PROTOCOL_VERSION);
     const CMasternodePing mnp = (deferRelay
                                     ? createDelayedMasternodePing(mnbRet)
                                     : createCurrentPing(txin));
@@ -308,6 +331,7 @@ bool CMasternodeBroadcastFactory::Create(
     const CService& service,
     const CKey& keyCollateralAddressNew,
     const CPubKey& pubKeyCollateralAddressNew,
+    const CScript& rewardScript,
     const CKey& keyMasternodeNew,
     const CPubKey& pubKeyMasternodeNew,
     const MasternodeTier nMasternodeTier,
@@ -319,7 +343,7 @@ bool CMasternodeBroadcastFactory::Create(
     if (fImporting || fReindex) return false;
 
     createWithoutSignatures(
-        txin,service,pubKeyCollateralAddressNew,pubKeyMasternodeNew,nMasternodeTier,deferRelay,mnbRet);
+        txin,service,pubKeyCollateralAddressNew,rewardScript,pubKeyMasternodeNew,nMasternodeTier,deferRelay,mnbRet);
 
     if(!provideSignatures(keyMasternodeNew,pubKeyMasternodeNew,keyCollateralAddressNew,mnbRet,strErrorRet))
     {
diff --git a/divi/src/MasternodeBroadcastFactory.h b/divi/src/MasternodeBroadcastFactory.h
index 2f576f060..b44c1c7f6 100644
--- a/divi/src/MasternodeBroadcastFactory.h
+++ b/divi/src/MasternodeBroadcastFactory.h
@@ -40,6 +40,7 @@ class CMasternodeBroadcastFactory
         const CTxIn& txin,
         const CService& service,
         const CPubKey& pubKeyCollateralAddressNew,
+        const CScript& rewardScript,
         const CPubKey& pubKeyMasternodeNew,
         MasternodeTier nMasternodeTier,
         bool deferRelay,
@@ -61,6 +62,7 @@ class CMasternodeBroadcastFactory
                        const CService& service,
                        const CKey& keyCollateralAddressNew,
                        const CPubKey& pubKeyCollateralAddressNew,
+                       const CScript& rewardScript,
                        const CKey& keyMasternodeNew,
                        const CPubKey& pubKeyMasternodeNew,
                        MasternodeTier nMasternodeTier,
diff --git a/divi/src/masternode.cpp b/divi/src/masternode.cpp
index 2fbb6f8b5..db4be5654 100644
--- a/divi/src/masternode.cpp
+++ b/divi/src/masternode.cpp
@@ -133,6 +133,11 @@ CMasternode& CMasternode::operator=(CMasternode from)
 }
 
 CScript CMasternode::GetDefaultRewardScript() const
+{
+    return GetDefaultRewardScript(pubKeyCollateralAddress);
+}
+
+CScript CMasternode::GetDefaultRewardScript(const CPubKey& pubKeyCollateralAddress)
 {
     return GetScriptForDestination(pubKeyCollateralAddress.GetID());
 }
@@ -268,13 +273,13 @@ bool CMasternode::IsValidNetAddr() const
 
 CMasternodeBroadcast::CMasternodeBroadcast(
     const CService& newAddr, const CTxIn& newVin,
-    const CPubKey& pubKeyCollateralAddressNew, const CPubKey& pubKeyMasternodeNew,
+    const CPubKey& pubKeyCollateralAddressNew, const CScript& rewardScriptIn, const CPubKey& pubKeyMasternodeNew,
     const MasternodeTier nMasternodeTier, const int protocolVersionIn)
 {
     vin = newVin;
     addr = newAddr;
     pubKeyCollateralAddress = pubKeyCollateralAddressNew;
-    rewardScript = GetDefaultRewardScript();
+    rewardScript = rewardScriptIn;
     pubKeyMasternode = pubKeyMasternodeNew;
     protocolVersion = protocolVersionIn;
     nTier = nMasternodeTier;
diff --git a/divi/src/masternode.h b/divi/src/masternode.h
index 577a3a47e..6b29b4b7a 100644
--- a/divi/src/masternode.h
+++ b/divi/src/masternode.h
@@ -98,6 +98,7 @@ class CMasternode
     /** Returns the "default" reward script, which is the one
      *  matching the collateral address.  */
     CScript GetDefaultRewardScript() const;
+    static CScript GetDefaultRewardScript(const CPubKey& pubKeyCollateralAddress);
 
     /** Calculates the score of the current masternode, based on the given
      *  seed hash.  It should be the result of GetBlockHashForScoring of
@@ -161,6 +162,7 @@ class CMasternodeBroadcast : public CMasternode
         const CService& newAddr,
         const CTxIn& newVin,
         const CPubKey& pubKeyCollateralAddress,
+        const CScript& rewardScriptIn,
         const CPubKey& pubKeyMasternode,
         MasternodeTier nMasternodeTier,
         int protocolVersionIn);
diff --git a/divi/src/masternodeconfig.cpp b/divi/src/masternodeconfig.cpp
index c48f8304d..28667157c 100644
--- a/divi/src/masternodeconfig.cpp
+++ b/divi/src/masternodeconfig.cpp
@@ -25,9 +25,10 @@ boost::filesystem::path GetMasternodeConfigFile()
 }
 
 void CMasternodeConfig::add(const std::string& alias, const std::string& ip, const std::string& privKey,
-                            const std::string& txHash, const std::string& outputIndex)
+                            const std::string& txHash, const std::string& outputIndex,
+                            const std::string& rewardAddr)
 {
-    entries.emplace_back(alias, ip, privKey, txHash, outputIndex);
+    entries.emplace_back(alias, ip, privKey, txHash, outputIndex, rewardAddr);
 }
 
 bool CMasternodeConfig::read(std::string& strErr)
@@ -71,7 +72,12 @@ bool CMasternodeConfig::read(std::string& strErr)
             }
         }
 
-        add(alias, ip, privKey, txHash, outputIndex);
+        /* This might fail if there is no address, but that is fine and we will
+           just leave the string empty in that case.  */
+        std::string rewardAddr;
+        iss >> rewardAddr;
+
+        add(alias, ip, privKey, txHash, outputIndex, rewardAddr);
     }
 
     streamConfig.close();
diff --git a/divi/src/masternodeconfig.h b/divi/src/masternodeconfig.h
index 2d34edb4a..7366d14e9 100644
--- a/divi/src/masternodeconfig.h
+++ b/divi/src/masternodeconfig.h
@@ -23,17 +23,20 @@ class CMasternodeConfig
         std::string privKey;
         std::string txHash;
         std::string outputIndex;
+        std::string rewardAddress;
 
     public:
         CMasternodeEntry(const std::string& alias, const std::string& ip,
                          const std::string& privKey,
-                         const std::string& txHash, const std::string& outputIndex)
+                         const std::string& txHash, const std::string& outputIndex,
+                         const std::string& rewardAddress)
         {
             this->alias = alias;
             this->ip = ip;
             this->privKey = privKey;
             this->txHash = txHash;
             this->outputIndex = outputIndex;
+            this->rewardAddress = rewardAddress;
         }
 
         const std::string& getAlias() const
@@ -87,6 +90,16 @@ class CMasternodeConfig
         {
             this->ip = ip;
         }
+
+        const std::string& getRewardAddress() const
+        {
+            return rewardAddress;
+        }
+
+        void setRewardAddress(const std::string& addr)
+        {
+            this->rewardAddress = addr;
+        }
     };
 
     CMasternodeConfig();
@@ -94,7 +107,8 @@ class CMasternodeConfig
     void clear();
     bool read(std::string& strErr);
     void add(const std::string& alias, const std::string& ip, const std::string& privKey,
-             const std::string& txHash, const std::string& outputIndex);
+             const std::string& txHash, const std::string& outputIndex,
+             const std::string& rewardAddr);
     const std::vector<CMasternodeEntry>& getEntries() const;
     int getCount() const;
 
diff --git a/divi/src/rpcmasternode.cpp b/divi/src/rpcmasternode.cpp
index 64d2b12a0..0ecca32c3 100644
--- a/divi/src/rpcmasternode.cpp
+++ b/divi/src/rpcmasternode.cpp
@@ -266,7 +266,7 @@ Value setupmasternode(const Array& params, bool fHelp)
     if (ipAndPort.find(':') == std::string::npos)
         ipAndPort += ":" + std::to_string(Params().GetDefaultPort());
 
-    CMasternodeConfig::CMasternodeEntry config(alias,ipAndPort,CBitcoinSecret(masternodeKey).ToString(),txHash,outputIndex);
+    CMasternodeConfig::CMasternodeEntry config(alias,ipAndPort,CBitcoinSecret(masternodeKey).ToString(),txHash,outputIndex, "");
 
     CMasternodeBroadcast mnb;
     std::string errorMsg;
diff --git a/divi/src/test/ActiveMasternode_tests.cpp b/divi/src/test/ActiveMasternode_tests.cpp
index a13b0838a..97f7a9376 100644
--- a/divi/src/test/ActiveMasternode_tests.cpp
+++ b/divi/src/test/ActiveMasternode_tests.cpp
@@ -25,7 +25,7 @@ class ActiveMasternodeTestFixture
 
     void AddDummyConfiguration(CTxIn txIn, CService service)
     {
-        configurations_->add("dummy configuration", service.ToString(), "", txIn.prevout.hash.ToString(), std::to_string(txIn.prevout.n));
+        configurations_->add("dummy configuration", service.ToString(), "", txIn.prevout.hash.ToString(), std::to_string(txIn.prevout.n), "");
     }
 };
 
@@ -98,4 +98,4 @@ BOOST_AUTO_TEST_CASE(willSetMatchingPubkeyForPrivateKey)
     BOOST_CHECK(activeMasternode_->pubKeyMasternode == expectedPubkey);
 }
 
-BOOST_AUTO_TEST_SUITE_END()
\ No newline at end of file
+BOOST_AUTO_TEST_SUITE_END()

From a206c659378358d787155c55e8e7253386e4d231 Mon Sep 17 00:00:00 2001
From: Daniel Kraft <d@domob.eu>
Date: Wed, 14 Oct 2020 15:20:23 +0200
Subject: [PATCH 7/9] Test custom reward address in mnoperation.py.

Use a custom reward address for one of the two masternodes in the
mnoperation.py regtest, verifying that this works.
---
 divi/qa/rpc-tests/masternode.py   | 17 ++++++++++++++++-
 divi/qa/rpc-tests/mncollateral.py |  1 +
 divi/qa/rpc-tests/mnoperation.py  | 15 +++++++++------
 3 files changed, 26 insertions(+), 7 deletions(-)

diff --git a/divi/qa/rpc-tests/masternode.py b/divi/qa/rpc-tests/masternode.py
index 6fc101943..254446043 100644
--- a/divi/qa/rpc-tests/masternode.py
+++ b/divi/qa/rpc-tests/masternode.py
@@ -12,7 +12,7 @@ class MnConfigLine (object):
 
   def __init__ (self, line):
     parts = line.split (" ")
-    assert_equal (len (parts), 5)
+    assert len (parts) in [5, 6]
 
     self.line = line
 
@@ -22,6 +22,21 @@ def __init__ (self, line):
     self.txid = parts[3]
     self.vout = int (parts[4])
 
+    if len (parts) >= 6:
+      self.rewardAddr = parts[5]
+    else:
+      self.rewardAddr = None
+
+  def getLine (self):
+    """Returns the config line as string, to put into masternode.conf."""
+
+    res = "%s %s %s %s %d" % (self.alias, self.ip, self.privkey,
+                              self.txid, self.vout)
+    if self.rewardAddr is not None:
+      res += " %s" % self.rewardAddr
+
+    return res
+
 
 def fund_masternode (node, alias, tier, txid, ip):
   """Calls fundmasternode with the given data and returns the
diff --git a/divi/qa/rpc-tests/mncollateral.py b/divi/qa/rpc-tests/mncollateral.py
index 1614c74c5..ce6bb4305 100755
--- a/divi/qa/rpc-tests/mncollateral.py
+++ b/divi/qa/rpc-tests/mncollateral.py
@@ -59,6 +59,7 @@ def run_test (self):
     assert_equal (cfg.alias, "spent")
     assert_equal (cfg.ip, "1.2.3.4:51476")
     assert_equal (cfg.txid, txid)
+    assert_equal (cfg.rewardAddr, None)
     assert_equal (node.gettxout (cfg.txid, cfg.vout)["value"], 300)
 
     # It should still be possible to spend the coins, invalidating the
diff --git a/divi/qa/rpc-tests/mnoperation.py b/divi/qa/rpc-tests/mnoperation.py
index ba0b9b883..af88f3e0a 100755
--- a/divi/qa/rpc-tests/mnoperation.py
+++ b/divi/qa/rpc-tests/mnoperation.py
@@ -69,9 +69,9 @@ def start_node (self, n):
     and masternode config for it."""
 
     configs = [
-      [c.line for c in self.cfg],
-      [self.cfg[0].line],
-      [self.cfg[1].line],
+      [c.getLine () for c in self.cfg],
+      [self.cfg[0].getLine ()],
+      [self.cfg[1].getLine ()],
     ]
 
     args = self.base_args[:]
@@ -141,6 +141,8 @@ def fund_masternodes (self):
       fund_masternode (self.nodes[0], "mn2", "silver", id2, "localhost:%d" % p2p_port (2)),
     ]
 
+    self.cfg[1].rewardAddr = self.nodes[0].getnewaddress ("reward2")
+
   def start_masternodes (self):
     print ("Starting masternodes...")
 
@@ -264,7 +266,7 @@ def payments_both_active (self):
     winners = self.verify_number_of_votes_exist_and_tally_winners(startHeight,endHeight, 2)
 
     addr1 = self.nodes[1].getmasternodestatus ()["addr"]
-    addr2 = self.nodes[2].getmasternodestatus ()["addr"]
+    addr2 = self.cfg[1].rewardAddr
     assert_equal (len (winners), 2)
     assert_greater_than (winners[addr1], 0)
     assert_greater_than (winners[addr2], 0)
@@ -309,8 +311,9 @@ def check_rewards (self):
     self.start_node (0)
     sync_blocks (self.nodes)
 
-    assert_greater_than (self.nodes[0].getbalance ("alloc->mn1"), 0)
-    assert_greater_than (self.nodes[0].getbalance ("alloc->mn2"), 0)
+    assert_greater_than (self.nodes[0].getbalance ("alloc->mn1"), 100)
+    assert_equal (self.nodes[0].getbalance ("alloc->mn2"), 300)
+    assert_greater_than (self.nodes[0].getbalance ("reward2"), 0)
 
 
 if __name__ == '__main__':

From 4a1a17f001cd150d6565ca9131bf5b16e23d9cdf Mon Sep 17 00:00:00 2001
From: Daniel Kraft <d@domob.eu>
Date: Fri, 16 Oct 2020 15:32:49 +0200
Subject: [PATCH 8/9] Activate new protocol with fork.

This defines a new time-activated "fork", Fork::CustomRewardAddresses.
For now, it is scheduled at timestamp 2000000000; that will be set to
the actual activation time once it is determined.

When this fork becomes active (i.e. the current best block's timestamp
goes beyond the activation time), we require peers to use the new protocol
version that supports custom reward addresses.  The fork has no other
(in particular, no consensus-level) consequences.
---
 divi/src/ForkActivation.cpp |  3 +++
 divi/src/ForkActivation.h   |  7 +++++++
 divi/src/main.cpp           |  1 +
 divi/src/version.cpp        | 16 ++++++++++++----
 4 files changed, 23 insertions(+), 4 deletions(-)

diff --git a/divi/src/ForkActivation.cpp b/divi/src/ForkActivation.cpp
index a05e2dd35..384108346 100644
--- a/divi/src/ForkActivation.cpp
+++ b/divi/src/ForkActivation.cpp
@@ -25,6 +25,9 @@ const std::unordered_map<Fork, int64_t,std::hash<int>> ACTIVATION_TIMES = {
   {Fork::TestByTimestamp, 1000000000},
   {Fork::HardenedStakeModifier, unixTimestampForDec31stMidnight},
   {Fork::UniformLotteryWinners, unixTimestampForDec31stMidnight},
+
+  /** FIXME: Set actual time once scheduled.  */
+  {Fork::CustomRewardAddresses, 2000000000},
 };
 
 } // anonymous namespace
diff --git a/divi/src/ForkActivation.h b/divi/src/ForkActivation.h
index 79aeb7ba6..e1c43dc6d 100644
--- a/divi/src/ForkActivation.h
+++ b/divi/src/ForkActivation.h
@@ -22,6 +22,13 @@ enum Fork
   TestByTimestamp,
   HardenedStakeModifier,
   UniformLotteryWinners,
+
+  /**
+   * Custom reward addresses for masternodes.  This is activated like other
+   * forks based on block time; but it only affects the network protocol
+   * we require from peers, not the actual consensus logic.
+   */
+  CustomRewardAddresses,
 };
 
 /**
diff --git a/divi/src/main.cpp b/divi/src/main.cpp
index 717071c42..cef693d78 100755
--- a/divi/src/main.cpp
+++ b/divi/src/main.cpp
@@ -15,6 +15,7 @@
 #include "BlockSigning.h"
 #include "checkpoints.h"
 #include "checkqueue.h"
+#include "ForkActivation.h"
 #include "init.h"
 #include "kernel.h"
 #include "masternode-payments.h"
diff --git a/divi/src/version.cpp b/divi/src/version.cpp
index dac54f414..f80123ea8 100644
--- a/divi/src/version.cpp
+++ b/divi/src/version.cpp
@@ -1,21 +1,29 @@
 #include <version.h>
 
+#include <chain.h>
 #include <chainparams.h>
+#include <ForkActivation.h>
 #include <Settings.h>
 
+extern CChain chainActive;
 extern Settings& settings;
 
-// Note: whenever a protocol update is needed toggle between both implementations (comment out the formerly active one)
-//       so we can leave the existing clients untouched (old SPORK will stay on so they don't see even older clients).
-//       Those old clients won't react to the changes of the other (new) SPORK because at the time of their implementation
-//       it was the one which was commented out
 int ActiveProtocol()
 {
     if (settings.ParameterIsSet("-activeversion"))
         return settings.GetArg("-activeversion", 0);
 
+    /* On regtest, we set the new protocol as active without any further
+       ado.  This allows proper testing of the changed logic.  */
     if (Params().NetworkID() == CBaseChainParams::REGTEST)
         return MN_REWARD_SCRIPT_VERSION;
 
+    /* Otherwise, the protocol update is tied to time-based activation of
+       a network fork (which in fact does not fork consensus but just the
+       network protocol).  */
+    const CBlockIndex* tip = chainActive.Tip();
+    if (tip != nullptr && ActivationState(tip).IsActive(Fork::CustomRewardAddresses))
+        return MN_REWARD_SCRIPT_VERSION;
+
     return MIN_PEER_PROTO_VERSION_AFTER_ENFORCEMENT;
 }

From 1e89b5a4a03fcb568bb3c961b9a60711d43288df Mon Sep 17 00:00:00 2001
From: Daniel Kraft <d@domob.eu>
Date: Tue, 16 Feb 2021 14:52:16 +0100
Subject: [PATCH 9/9] Regtest for update backwards compatibility.

This adds a new regtest, custom_address_update.py.  The test runs
two masternodes, where we explicitly set the protocol version of
one of the nodes to the "old" version not supporting custom reward
scripts for masternodes.

With this test, we ensure that all the masternode networking works fine
between "old" and "new" nodes before the update is activated, at least
as closely as we can without running a real old node.
---
 divi/qa/rpc-tests/custom_address_update.py | 179 +++++++++++++++++++++
 divi/qa/rpc-tests/test_runner.py           |   1 +
 2 files changed, 180 insertions(+)
 create mode 100755 divi/qa/rpc-tests/custom_address_update.py

diff --git a/divi/qa/rpc-tests/custom_address_update.py b/divi/qa/rpc-tests/custom_address_update.py
new file mode 100755
index 000000000..43679e2e1
--- /dev/null
+++ b/divi/qa/rpc-tests/custom_address_update.py
@@ -0,0 +1,179 @@
+#!/usr/bin/env python3
+# Copyright (c) 2020-2021 The DIVI developers
+# Distributed under the MIT/X11 software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+# Tests that nodes with support for custom reward addresses are compatible
+# to nodes without it before the change actually activates.  For this,
+# we run two masternodes (one with and one without support) and check
+# that they can both see each other's masternode.
+#
+# We use five nodes:
+# - node 0 is a masternode with default protocol (i.e. "new")
+# - node 1 is a masternode with previous protocol (i.e. "old")
+# - nodes 2-4 are just used to get above the "three full nodes" threshold
+
+from test_framework import BitcoinTestFramework
+from util import *
+from masternode import *
+
+import collections
+import time
+
+OLD_PROTOCOL = 70915
+NEW_PROTOCOL = 71000
+
+
+def args_for (n):
+  base = ["-debug", "-nolistenonion", "-activeversion=%d" % OLD_PROTOCOL]
+  if n == 1:
+    base.extend (["-protocolversion=%d" % OLD_PROTOCOL])
+  return base
+
+
+class CustomAddressUpdateTest (BitcoinTestFramework):
+
+  def setup_chain (self):
+    for i in range (5):
+      initialize_datadir (self.options.tmpdir, i)
+
+  def setup_network (self, config_line=None, extra_args=[]):
+    self.nodes = [
+      start_node (i, self.options.tmpdir, extra_args=args_for (i))
+      for i in range (5)
+    ]
+
+    # We want to work with mock times that are beyond the genesis
+    # block timestamp but before current time (so that nodes being
+    # started up and before they get on mocktime aren't rejecting
+    # the on-disk blockchain).
+    self.time = 1580000000
+    assert self.time < time.time ()
+    set_node_times (self.nodes, self.time)
+
+    connect_nodes (self.nodes[0], 2)
+    connect_nodes (self.nodes[1], 2)
+    connect_nodes (self.nodes[2], 3)
+    connect_nodes (self.nodes[2], 4)
+    connect_nodes (self.nodes[3], 4)
+
+    self.is_network_split = False
+
+  def start_node (self, n):
+    """Starts node n (0 or 1) with the proper arguments
+    and masternode config for it."""
+
+    assert n in [0, 1]
+    configs = [[c.getLine ()] for c in self.cfg]
+
+    args = args_for (n)
+    args.append ("-masternode")
+    args.append ("-masternodeprivkey=%s" % self.cfg[n].privkey)
+    args.append ("-masternodeaddr=127.0.0.1:%d" % p2p_port (n))
+
+    self.nodes[n] = start_node (n, self.options.tmpdir,
+                                extra_args=args, mn_config_lines=configs[n])
+    self.nodes[n].setmocktime (self.time)
+
+    for i in [2, 3, 4]:
+      connect_nodes (self.nodes[n], i)
+    sync_blocks (self.nodes)
+
+  def stop_node (self, n):
+    """Stops node n."""
+
+    stop_node (self.nodes[n], n)
+    self.nodes[n] = None
+
+  def advance_time (self, dt=1):
+    """Advances mocktime by the given number of seconds."""
+
+    self.time += dt
+    set_node_times (self.nodes, self.time)
+
+  def mine_blocks (self, n):
+    """Mines blocks with node 2."""
+
+    self.nodes[2].setgenerate(True, n)
+    sync_blocks (self.nodes)
+
+  def run_test (self):
+    assert_equal (self.nodes[0].getnetworkinfo ()["protocolversion"], NEW_PROTOCOL)
+    assert_equal (self.nodes[1].getnetworkinfo ()["protocolversion"], OLD_PROTOCOL)
+
+    self.fund_masternodes ()
+    self.start_masternodes ()
+
+  def fund_masternodes (self):
+    print ("Funding masternodes...")
+
+    # The collateral needs 15 confirmations, and the masternode broadcast
+    # signature must be later than that block's timestamp.  Thus we start
+    # with a very early timestamp.
+    genesis = self.nodes[0].getblockhash (0)
+    genesisTime = self.nodes[0].getblockheader (genesis)["time"]
+    assert genesisTime < self.time
+    set_node_times (self.nodes, genesisTime)
+
+    self.nodes[0].setgenerate (True, 1)
+    sync_blocks (self.nodes)
+    self.nodes[1].setgenerate (True, 1)
+    sync_blocks (self.nodes)
+    self.mine_blocks (25)
+    assert_equal (self.nodes[0].getbalance (), 1250)
+    assert_equal (self.nodes[1].getbalance (), 1250)
+
+    id1 = self.nodes[0].allocatefunds ("masternode", "mn1", "copper")["txhash"]
+    id2 = self.nodes[1].allocatefunds ("masternode", "mn2", "copper")["txhash"]
+    sync_mempools (self.nodes)
+    self.mine_blocks (15)
+    set_node_times (self.nodes, self.time)
+    self.mine_blocks (1)
+
+    self.cfg = [
+      fund_masternode (self.nodes[0], "mn1", "copper", id1, "localhost:%d" % p2p_port (0)),
+      fund_masternode (self.nodes[1], "mn2", "copper", id2, "localhost:%d" % p2p_port (1)),
+    ]
+
+  def start_masternodes (self):
+    print ("Starting masternodes...")
+
+    for i in range (2):
+      self.stop_node (i)
+      self.start_node (i)
+
+    # Start the masternodes after the nodes are back up and connected
+    # (so they will receive each other's broadcast).
+    for i in range (2):
+      res = self.nodes[i].startmasternode ("mn%d" % (i + 1))
+      assert_equal (res, {"status": "success"})
+
+    # Check status of the masternodes themselves.
+    for i in [0, 1]:
+      data = self.nodes[i].getmasternodestatus ()
+      assert_equal (data["status"], 4)
+      assert_equal (data["txhash"], self.cfg[i].txid)
+      assert_equal (data["outputidx"], self.cfg[i].vout)
+      assert_equal (data["message"], "Masternode successfully started")
+
+    # Both masternodes should see each other, independent of the
+    # protocol version used.
+    lists = [{}] * 2
+    for i in range (2):
+      cur = self.nodes[i].listmasternodes ()
+      while len (cur) < 2:
+        time.sleep (0.1)
+        cur = self.nodes[i].listmasternodes ()
+      for c in cur:
+        lists[i][c["txhash"]] = c
+    assert_equal (lists[0], lists[1])
+
+    lst = lists[0]
+    assert_equal (len (lst), 2)
+    for val in lst.values ():
+      assert_equal (val["tier"], "COPPER")
+      assert_equal (val["status"], "ENABLED")
+
+
+if __name__ == '__main__':
+  CustomAddressUpdateTest ().main ()
diff --git a/divi/qa/rpc-tests/test_runner.py b/divi/qa/rpc-tests/test_runner.py
index ab807ee38..05c581744 100755
--- a/divi/qa/rpc-tests/test_runner.py
+++ b/divi/qa/rpc-tests/test_runner.py
@@ -78,6 +78,7 @@
     'StakingVaultStaking.py',
     'StakingVaultDeactivation.py',
     'StakingVaultSpam.py',
+    'custom_address_update.py',
     'forknotify.py',
     'getchaintips.py',
     'httpbasics.py',