From a94a603f5a7cd56120a608109853514c10e227b4 Mon Sep 17 00:00:00 2001
From: Daniel Kraft <d@domob.eu>
Date: Thu, 8 Oct 2020 15:56:35 +0200
Subject: [PATCH 1/8] 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/qa/rpc-tests/masternode.py    |  3 ++-
 divi/src/RpcMasternodeFeatures.cpp |  4 ++++
 divi/src/RpcMasternodeFeatures.h   |  2 ++
 divi/src/masternode.cpp            |  9 ++++++++-
 divi/src/masternode.h              | 17 +++++++++++++++++
 divi/src/masternodeman.cpp         |  1 +
 divi/src/rpcmasternode.cpp         |  4 +++-
 7 files changed, 37 insertions(+), 3 deletions(-)

diff --git a/divi/qa/rpc-tests/masternode.py b/divi/qa/rpc-tests/masternode.py
index 8242cd007..9f63066d6 100644
--- a/divi/qa/rpc-tests/masternode.py
+++ b/divi/qa/rpc-tests/masternode.py
@@ -220,6 +220,7 @@ def find_mn(nodeIndex):
           assert_equal (local_status["status"], 4)
           assert_equal(local_status["txhash"],listedMN["txhash"])
           assert_equal(local_status["outputidx"],listedMN["outidx"])
+          assert_equal(local_status["rewardscript"],listedMN["rewardscript"])
           node_found = True
       assert_equal(node_found,True)
     self.for_each_masternode(find_mn)
@@ -237,4 +238,4 @@ def mock_wait(self,duration=1):
     for _ in range(duration):
       self.time +=1
       set_node_times(self.nodes,self.time)
-      time.sleep(0.01)
\ No newline at end of file
+      time.sleep(0.01)
diff --git a/divi/src/RpcMasternodeFeatures.cpp b/divi/src/RpcMasternodeFeatures.cpp
index 9af24ad6d..5965fa85d 100644
--- a/divi/src/RpcMasternodeFeatures.cpp
+++ b/divi/src/RpcMasternodeFeatures.cpp
@@ -45,6 +45,7 @@ ActiveMasternodeStatus::ActiveMasternodeStatus(
     , outputIndex()
     , netAddress()
     , collateralAddress()
+    , rewardScript()
     , statusCode()
     , statusMessage()
 {}
@@ -54,6 +55,7 @@ MasternodeListEntry::MasternodeListEntry(
     , outputIndex()
     , status()
     , collateralAddress()
+    , rewardScript()
     , protocolVersion()
     , signatureTime()
     , lastSeenTime()
@@ -228,6 +230,7 @@ ActiveMasternodeStatus GetActiveMasternodeStatus()
         result.outputIndex = std::to_string(activeMasternode.vin.prevout.n);
         result.netAddress = activeMasternode.service.ToString();
         result.collateralAddress = CBitcoinAddress(mn.pubKeyCollateralAddress.GetID()).ToString();
+        result.rewardScript = HexStr(mn.rewardScript);
         result.statusCode = std::to_string(activeMasternode.status);
         result.statusMessage = activeMasternode.GetStatus();
         result.activeMasternodeFound = true;
@@ -315,6 +318,7 @@ std::vector<MasternodeListEntry> GetMasternodeList(std::string strFilter, CBlock
         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);
diff --git a/divi/src/RpcMasternodeFeatures.h b/divi/src/RpcMasternodeFeatures.h
index cf2a610f4..87ab40395 100644
--- a/divi/src/RpcMasternodeFeatures.h
+++ b/divi/src/RpcMasternodeFeatures.h
@@ -20,6 +20,7 @@ struct ActiveMasternodeStatus
     std::string outputIndex;
     std::string netAddress;
     std::string collateralAddress;
+    std::string rewardScript;
     std::string statusCode;
     std::string statusMessage;
     ActiveMasternodeStatus();
@@ -31,6 +32,7 @@ struct MasternodeListEntry
     uint64_t outputIndex;
     std::string status;
     std::string collateralAddress;
+    std::string rewardScript;
     int protocolVersion;
     int64_t signatureTime;
     int64_t lastSeenTime;
diff --git a/divi/src/masternode.cpp b/divi/src/masternode.cpp
index c4586ab94..51c451823 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;
@@ -83,6 +83,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;
@@ -108,6 +109,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);
@@ -127,6 +129,11 @@ CMasternode& CMasternode::operator=(CMasternode from)
     return *this;
 }
 
+CScript CMasternode::GetDefaultRewardScript() const
+{
+    return GetScriptForDestination(pubKeyCollateralAddress.GetID());
+}
+
 bool CMasternode::IsEnabled() const
 {
     return activeState == MASTERNODE_ENABLED;
diff --git a/divi/src/masternode.h b/divi/src/masternode.h
index 2cbd6525c..cee512a7b 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)
@@ -50,6 +51,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;
@@ -81,6 +86,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
      *  scoring hash.  It should be the result of GetBlockHashForScoring of
      *  the target block height.  */
@@ -106,6 +115,7 @@ class CMasternode
         READWRITE(vin);
         READWRITE(addr);
         READWRITE(pubKeyCollateralAddress);
+        READWRITE(rewardScript);
         READWRITE(pubKeyMasternode);
         READWRITE(signature);
         READWRITE(sigTime);
@@ -149,6 +159,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 475847718..cf87cdb64 100644
--- a/divi/src/masternodeman.cpp
+++ b/divi/src/masternodeman.cpp
@@ -183,6 +183,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 191956cf8..2e8500873 100644
--- a/divi/src/rpcmasternode.cpp
+++ b/divi/src/rpcmasternode.cpp
@@ -396,12 +396,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);
@@ -564,6 +565,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 6e00f634551639443c9ca78147d2bced8e2af7a4 Mon Sep 17 00:00:00 2001
From: Daniel Kraft <d@domob.eu>
Date: Fri, 9 Oct 2020 14:31:52 +0200
Subject: [PATCH 2/8] 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/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 +++
 5 files changed, 41 insertions(+), 10 deletions(-)

diff --git a/divi/src/masternode.cpp b/divi/src/masternode.cpp
index 51c451823..4309be29d 100644
--- a/divi/src/masternode.cpp
+++ b/divi/src/masternode.cpp
@@ -13,6 +13,8 @@
 #include <streams.h>
 #include <net.h>
 
+#include <sstream>
+
 CAmount CMasternode::GetTierCollateralAmount(const MasternodeTier tier)
 {
     const auto& collateralMap = Params().MasternodeCollateralMap();
@@ -253,10 +255,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 cee512a7b..14d511bbc 100644
--- a/divi/src/masternode.h
+++ b/divi/src/masternode.h
@@ -159,12 +159,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 cf87cdb64..688ad239c 100644
--- a/divi/src/masternodeman.cpp
+++ b/divi/src/masternodeman.cpp
@@ -231,6 +231,12 @@ bool CMasternodeMan::CheckInputsForMasternode(const CMasternodeBroadcast& mnb, i
 
 bool CMasternodeMan::CheckMasternodeBroadcastContext(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);
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 99170d694b46be483d8d3ad60d21ce137d7a59e9 Mon Sep 17 00:00:00 2001
From: Daniel Kraft <d@domob.eu>
Date: Mon, 12 Oct 2020 16:42:15 +0200
Subject: [PATCH 3/8] 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/RpcMasternodeFeatures.cpp | 5 ++---
 divi/src/masternode-payments.cpp   | 5 +++--
 divi/src/masternode.cpp            | 3 +--
 3 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/divi/src/RpcMasternodeFeatures.cpp b/divi/src/RpcMasternodeFeatures.cpp
index 5965fa85d..bbbc4e741 100644
--- a/divi/src/RpcMasternodeFeatures.cpp
+++ b/divi/src/RpcMasternodeFeatures.cpp
@@ -247,7 +247,6 @@ ActiveMasternodeStatus GetActiveMasternodeStatus()
 unsigned FindLastPayeePaymentTime(CBlockIndex* chainTip, const MasternodePaymentData& paymentData, const CMasternode& masternode, const unsigned maxBlockDepth)
 {
     assert(chainTip);
-    CScript mnPayee = GetScriptForDestination(masternode.pubKeyCollateralAddress.GetID());
     unsigned n = 0;
     for (unsigned int i = 1; chainTip && chainTip->nHeight > 0; i++) {
         if (n >= maxBlockDepth) {
@@ -265,7 +264,7 @@ unsigned FindLastPayeePaymentTime(CBlockIndex* chainTip, const MasternodePayment
                 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();
             }
         }
@@ -317,7 +316,7 @@ std::vector<MasternodeListEntry> GetMasternodeList(std::string strFilter, CBlock
         entry.txHash = strTxHash;
         entry.outputIndex = oIdx;
         entry.status = strStatus;
-        entry.collateralAddress = CBitcoinAddress(masternode.pubKeyCollateralAddress.GetID()).ToString();
+        entry.collateralAddress = collateralAddress;
         entry.rewardScript = HexStr(masternode.rewardScript);
         entry.protocolVersion = masternode.protocolVersion;
         entry.lastSeenTime = (int64_t)masternode.lastPing.sigTime;
diff --git a/divi/src/masternode-payments.cpp b/divi/src/masternode-payments.cpp
index ec0e71791..0fd9ce279 100644
--- a/divi/src/masternode-payments.cpp
+++ b/divi/src/masternode-payments.cpp
@@ -16,6 +16,7 @@
 #include "sync.h"
 #include "Logging.h"
 #include "utilmoneystr.h"
+#include "utilstrencodings.h"
 #include "netfulfilledman.h"
 #include <boost/filesystem.hpp>
 #include <boost/lexical_cast.hpp>
@@ -454,7 +455,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
@@ -528,7 +529,7 @@ MnPaymentQueueData CMasternodePayments::GetMasternodePaymentQueue(const uint256&
     {
         if(pmn != nullptr && queueData.topTwentyMNPayees.size() < 2 * MNPAYMENTS_SIGNATURES_TOTAL)
         {
-            queueData.topTwentyMNPayees.push_back(GetScriptForDestination(pmn->pubKeyCollateralAddress.GetID()));
+            queueData.topTwentyMNPayees.push_back(pmn->GetPaymentScript());
         }
         else
         {
diff --git a/divi/src/masternode.cpp b/divi/src/masternode.cpp
index 4309be29d..0538d51c5 100644
--- a/divi/src/masternode.cpp
+++ b/divi/src/masternode.cpp
@@ -155,8 +155,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)

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

This extends the setupmasternode RPC method so that it allows setting
a non-default reward address.  The reward address is an optional sixth
argument following the ip_address.
---
 divi/src/MasternodeBroadcastFactory.cpp  | 21 ++++++++++++++++++---
 divi/src/MasternodeBroadcastFactory.h    |  2 ++
 divi/src/masternode.cpp                  |  5 +++++
 divi/src/masternode.h                    |  1 +
 divi/src/rpcmasternode.cpp               | 16 ++++++++++++++--
 divi/src/test/ActiveMasternode_tests.cpp |  2 +-
 6 files changed, 41 insertions(+), 6 deletions(-)

diff --git a/divi/src/MasternodeBroadcastFactory.cpp b/divi/src/MasternodeBroadcastFactory.cpp
index f4cd33351..7fe7ba777 100644
--- a/divi/src/MasternodeBroadcastFactory.cpp
+++ b/divi/src/MasternodeBroadcastFactory.cpp
@@ -7,6 +7,7 @@
 #include <obfuscation.h>
 #include <chain.h>
 #include <base58address.h>
+#include <script/standard.h>
 #include <TransactionDiskAccessor.h>
 #include <timedata.h>
 #include <WalletTx.h>
@@ -64,6 +65,8 @@ bool createArgumentsFromConfig(
     bool collateralPrivKeyIsRemote,
     CTxIn& txin,
     std::pair<CKey,CPubKey>& masternodeKeyPair,
+    const CPubKey& pubkeyCollateralAddress,
+    CScript& rewardScript,
     MasternodeTier& nMasternodeTier)
 {
     const std::string strService = configEntry.getIp();
@@ -90,6 +93,12 @@ bool createArgumentsFromConfig(
     {
         return false;
     }
+
+    /* If a custom reward address should be used, this is overridden by
+       setupmasternode directly after creating the entry (not loaded through
+       the config file).  */
+    rewardScript = CMasternode::GetDefaultRewardScript(pubkeyCollateralAddress);
+
     return true;
 }
 
@@ -107,6 +116,7 @@ bool CMasternodeBroadcastFactory::CreateWithoutCollateralKey(
     const bool collateralPrivateKeyIsRemote = true;
     const bool deferRelay = true;
     CTxIn txin;
+    CScript rewardScript;
     std::pair<CKey,CPubKey> masternodeKeyPair;
     MasternodeTier nMasternodeTier;
 
@@ -120,6 +130,8 @@ bool CMasternodeBroadcastFactory::CreateWithoutCollateralKey(
         collateralPrivateKeyIsRemote,
         txin,
         masternodeKeyPair,
+        pubkeyCollateralAddress,
+        rewardScript,
         nMasternodeTier))
     {
         return false;
@@ -129,6 +141,7 @@ bool CMasternodeBroadcastFactory::CreateWithoutCollateralKey(
         txin,
         CService(configEntry.getIp()),
         pubkeyCollateralAddress,
+        rewardScript,
         pubkeyMasternode,
         nMasternodeTier,
         deferRelay,
@@ -174,13 +187,14 @@ bool CMasternodeBroadcastFactory::signBroadcast(
 
 CMasternodeBroadcast CMasternodeBroadcastFactory::constructBroadcast(
     const CService& newAddr, const CTxIn& newVin,
-    const CPubKey& pubKeyCollateralAddressNew, const CPubKey& pubKeyMasternodeNew,
+    const CPubKey& pubKeyCollateralAddressNew, const CScript& rewardScript, const CPubKey& pubKeyMasternodeNew,
     const MasternodeTier nMasternodeTier, const int protocolVersionIn)
 {
     CMasternode mn;
     mn.vin = newVin;
     mn.addr = newAddr;
     mn.pubKeyCollateralAddress = pubKeyCollateralAddressNew;
+    mn.rewardScript = rewardScript;
     mn.pubKeyMasternode = pubKeyMasternodeNew;
     mn.protocolVersion = protocolVersionIn;
     mn.nTier = nMasternodeTier;
@@ -191,6 +205,7 @@ void CMasternodeBroadcastFactory::createWithoutSignatures(
     const CTxIn& txin,
     const CService& service,
     const CPubKey& pubKeyCollateralAddressNew,
+    const CScript& rewardScript,
     const CPubKey& pubKeyMasternodeNew,
     const MasternodeTier nMasternodeTier,
     bool deferRelay,
@@ -200,7 +215,7 @@ void CMasternodeBroadcastFactory::createWithoutSignatures(
              CBitcoinAddress(pubKeyCollateralAddressNew.GetID()).ToString(),
              pubKeyMasternodeNew.GetID().ToString());
 
-    mnbRet = CMasternodeBroadcastFactory::constructBroadcast(service, txin, pubKeyCollateralAddressNew, pubKeyMasternodeNew, nMasternodeTier, PROTOCOL_VERSION);
+    mnbRet = CMasternodeBroadcastFactory::constructBroadcast(service, txin, pubKeyCollateralAddressNew, rewardScript, pubKeyMasternodeNew, nMasternodeTier, PROTOCOL_VERSION);
     const CMasternodePing mnp = (deferRelay
                                     ? createDelayedMasternodePing(mnbRet)
                                     : createCurrentPing(txin));
@@ -222,4 +237,4 @@ void CMasternodeBroadcastFactory::createWithoutSignatures(
         mnbRet.sigTime = pindexConf->GetBlockTime();
         LogPrint("masternode", "Using collateral confirmation time for broadcast: %d\n", mnbRet.sigTime);
     }
-}
\ No newline at end of file
+}
diff --git a/divi/src/MasternodeBroadcastFactory.h b/divi/src/MasternodeBroadcastFactory.h
index 36840fef6..e4e553c5e 100644
--- a/divi/src/MasternodeBroadcastFactory.h
+++ b/divi/src/MasternodeBroadcastFactory.h
@@ -40,6 +40,7 @@ class CMasternodeBroadcastFactory
         const CService& newAddr,
         const CTxIn& newVin,
         const CPubKey& pubKeyCollateralAddress,
+        const CScript& rewardScript,
         const CPubKey& pubKeyMasternode,
         MasternodeTier nMasternodeTier,
         int protocolVersionIn);
@@ -47,6 +48,7 @@ class CMasternodeBroadcastFactory
         const CTxIn& txin,
         const CService& service,
         const CPubKey& pubKeyCollateralAddressNew,
+        const CScript& rewardScript,
         const CPubKey& pubKeyMasternodeNew,
         MasternodeTier nMasternodeTier,
         bool deferRelay,
diff --git a/divi/src/masternode.cpp b/divi/src/masternode.cpp
index 0538d51c5..eca4b33d5 100644
--- a/divi/src/masternode.cpp
+++ b/divi/src/masternode.cpp
@@ -132,6 +132,11 @@ CMasternode& CMasternode::operator=(CMasternode from)
 }
 
 CScript CMasternode::GetDefaultRewardScript() const
+{
+    return GetDefaultRewardScript(pubKeyCollateralAddress);
+}
+
+CScript CMasternode::GetDefaultRewardScript(const CPubKey& pubKeyCollateralAddress)
 {
     return GetScriptForDestination(pubKeyCollateralAddress.GetID());
 }
diff --git a/divi/src/masternode.h b/divi/src/masternode.h
index 14d511bbc..d4025a7dd 100644
--- a/divi/src/masternode.h
+++ b/divi/src/masternode.h
@@ -89,6 +89,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
      *  scoring hash.  It should be the result of GetBlockHashForScoring of
diff --git a/divi/src/rpcmasternode.cpp b/divi/src/rpcmasternode.cpp
index 2e8500873..a87211ebe 100644
--- a/divi/src/rpcmasternode.cpp
+++ b/divi/src/rpcmasternode.cpp
@@ -264,9 +264,9 @@ Value signmnbroadcast(const Array& params, bool fHelp)
 
 Value setupmasternode(const Array& params, bool fHelp)
 {
-	if (fHelp || params.size() < 5 || params.size() > 6)
+	if (fHelp || params.size() < 5 || params.size() > 7)
 		throw std::runtime_error(
-			"setupmasternode alias txhash outputIndex collateralPubKey ip_address\n"
+			"setupmasternode alias txhash outputIndex collateralPubKey ip_address (reward_address)\n"
 			"\nStarts escrows funds for some purpose.\n"
 
 			"\nArguments:\n"
@@ -275,6 +275,7 @@ Value setupmasternode(const Array& params, bool fHelp)
             "3. outputIndex         (string, required) Output index transaction. \n"
             "4. collateralPubkey    (string, required) collateral pubkey. \n"
             "5. ip_address          (string, required) Local ip address of this node\n"
+            "6. reward_address      (string, optional) A custom reward address, defaults to the collateral address\n"
 			"\nResult:\n"
 			"\"protocol_version\"			(string) Protocol version used for serialization.\n"
             "\"message_to_sign\"			(string) Hex-encoded msg requiring collateral signature.\n"
@@ -317,6 +318,17 @@ Value setupmasternode(const Array& params, bool fHelp)
         throw JSONRPCError(RPC_INVALID_PARAMS,errorMsg);
     }
 
+    /* If we have a custom reward address, override the one from the broadcast.
+       This is fine, as it would only invalidate the broadcast signature and
+       the broadcast created is not yet signed anyway.  */
+    if (params.size() >= 6 && !params[5].get_str().empty())
+    {
+        const CBitcoinAddress addr(params[5].get_str());
+        if (!addr.IsValid())
+            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, "Invalid reward address");
+        mnb.rewardScript = GetScriptForDestination(addr.Get());
+    }
+
     CDataStream ss(SER_NETWORK,PROTOCOL_VERSION);
     result.push_back(Pair("protocol_version", PROTOCOL_VERSION ));
     result.push_back(Pair("message_to_sign", HexStr(mnb.getMessageToSign()) ));
diff --git a/divi/src/test/ActiveMasternode_tests.cpp b/divi/src/test/ActiveMasternode_tests.cpp
index 18667802e..c2db7530f 100644
--- a/divi/src/test/ActiveMasternode_tests.cpp
+++ b/divi/src/test/ActiveMasternode_tests.cpp
@@ -131,4 +131,4 @@ BOOST_AUTO_TEST_CASE(willCannotResetStatusOfInactiveMasternodeWhenChainSyncIsReq
     BOOST_CHECK(activeMasternode_->status == ACTIVE_MASTERNODE_STARTED);
 }
 
-BOOST_AUTO_TEST_SUITE_END()
\ No newline at end of file
+BOOST_AUTO_TEST_SUITE_END()

From 65cc1b15386fb435882072bbd538e2af3615f069 Mon Sep 17 00:00:00 2001
From: Daniel Kraft <d@domob.eu>
Date: Wed, 14 Oct 2020 15:20:23 +0200
Subject: [PATCH 5/8] 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.

For the test, we activate the new protocol version on regtest without
any forking logic.
---
 divi/qa/rpc-tests/masternode.py  |  8 ++++----
 divi/qa/rpc-tests/mnoperation.py | 23 +++++++++++++++++++++--
 divi/src/version.cpp             |  6 ++++++
 3 files changed, 31 insertions(+), 6 deletions(-)

diff --git a/divi/qa/rpc-tests/masternode.py b/divi/qa/rpc-tests/masternode.py
index 9f63066d6..35786af3d 100644
--- a/divi/qa/rpc-tests/masternode.py
+++ b/divi/qa/rpc-tests/masternode.py
@@ -45,7 +45,7 @@ def __init__(self, setup_data,address=None):
     if address is not None:
       self.address = address
 
-def setup_masternode(mempoolSync,controlNode, hostNode,alias,tier,hostIP, utxo = None):
+def setup_masternode(mempoolSync,controlNode, hostNode,alias,tier,hostIP, utxo = None, rewardAddr=""):
   """Calls fundmasternode with the given data and returns the
   MnConfigLine instance."""
   txdata = None
@@ -62,7 +62,7 @@ def setup_masternode(mempoolSync,controlNode, hostNode,alias,tier,hostIP, utxo =
   pubkey = controlNode.validateaddress(address)["pubkey"]
   if sync_required:
     mempoolSync()
-  data = hostNode.setupmasternode(alias,txdata["txhash"],str(txdata["vout"]), pubkey, hostIP)
+  data = hostNode.setupmasternode(alias,txdata["txhash"],str(txdata["vout"]), pubkey, hostIP, rewardAddr)
   return MnSetupData (data,address)
 
 class MnTestFramework(BitcoinTestFramework):
@@ -86,12 +86,12 @@ def for_each_masternode(self, masternode_function):
 
     return result
 
-  def setup_masternode(self,controlNodeIndex, hostNodeIndex,alias,tier,utxo=None):
+  def setup_masternode(self,controlNodeIndex, hostNodeIndex,alias,tier,utxo=None, rewardAddr=""):
     def mempoolSync():
       sync_mempools (self.nodes)
     controlNode = self.nodes[controlNodeIndex]
     hostNode = self.nodes[hostNodeIndex]
-    self.setup[hostNodeIndex] = setup_masternode(mempoolSync,controlNode,hostNode,alias, tier,"localhost:%d" % p2p_port (hostNodeIndex),utxo=utxo)
+    self.setup[hostNodeIndex] = setup_masternode(mempoolSync,controlNode,hostNode,alias, tier,"localhost:%d" % p2p_port (hostNodeIndex),utxo=utxo, rewardAddr=rewardAddr)
     self.mn_control_node_indices[alias] = controlNodeIndex
     self.mn_host_node_indices[alias] = hostNodeIndex
 
diff --git a/divi/qa/rpc-tests/mnoperation.py b/divi/qa/rpc-tests/mnoperation.py
index e70732a65..e6dedcca1 100755
--- a/divi/qa/rpc-tests/mnoperation.py
+++ b/divi/qa/rpc-tests/mnoperation.py
@@ -57,6 +57,13 @@ def stop_node (self, n):
     stop_node (self.nodes[n], n)
     self.nodes[n] = None
 
+  def start_node (self, n):
+    """Starts a node."""
+
+    self.nodes[n] = start_node (n, self.options.tmpdir, extra_args=self.base_args)
+    for i in [3, 4, 5, 6]:
+      connect_nodes(self.nodes[n], i)
+
   def advance_time (self, dt=1,delay=None):
     """Advances mocktime by the given number of seconds."""
 
@@ -83,8 +90,9 @@ def fund_masternodes (self):
     self.mine_blocks (25)
     assert_equal (self.nodes[0].getbalance (), 6250)
 
+    self.rewardAddr = self.nodes[0].getnewaddress ("reward2")
     self.setup_masternode(0,1,"mn1","copper")
-    self.setup_masternode(0,2,"mn2","silver")
+    self.setup_masternode(0,2,"mn2","silver",rewardAddr=self.rewardAddr)
     self.mine_blocks (15)
     set_node_times (self.nodes, self.time)
     self.mine_blocks (1)
@@ -175,7 +183,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.rewardAddr
     assert_equal (len (winners), 2)
     assert_greater_than (winners[addr1], 0)
     assert_greater_than (winners[addr2], 0)
@@ -215,11 +223,22 @@ def payments_one_active (self):
     addr = self.nodes[1].getmasternodestatus ()["addr"]
     self.verify_number_of_votes_exist_and_tally_winners(startHeight,endHeight,1,addr)
 
+  def check_rewards (self):
+    print ("Checking rewards in wallet...")
+
+    self.start_node (0)
+    sync_blocks (self.nodes)
+
+    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)
+
   def run_test (self):
     self.fund_masternodes ()
     self.start_masternodes ()
     self.payments_both_active ()
     self.payments_one_active ()
+    self.check_rewards ()
 
 if __name__ == '__main__':
   MnStatusTest ().main ()
diff --git a/divi/src/version.cpp b/divi/src/version.cpp
index b4f3ebfd6..358a04448 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,10 @@ 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;
+
     return MIN_PEER_PROTO_VERSION_AFTER_ENFORCEMENT;
 }

From 1d1865c5f899fccf27eee775f65fdcabc838ab45 Mon Sep 17 00:00:00 2001
From: Daniel Kraft <d@domob.eu>
Date: Thu, 13 May 2021 16:29:02 +0200
Subject: [PATCH 6/8] Use custom reward address in mnvaults.py.

Custom reward addresses are one of the core features needed for
proper masternode vaults.  With them implemented now, we can update
the mnvaults.py test (resolving two FIXME's in there) to actually make
use of an explicit reward address so that the masternode rewards are
received and not lost (as we want them to be in practice).
---
 divi/qa/rpc-tests/mnvaults.py | 20 ++++++++++++--------
 1 file changed, 12 insertions(+), 8 deletions(-)

diff --git a/divi/qa/rpc-tests/mnvaults.py b/divi/qa/rpc-tests/mnvaults.py
index 330736cd6..27e2ce4f7 100755
--- a/divi/qa/rpc-tests/mnvaults.py
+++ b/divi/qa/rpc-tests/mnvaults.py
@@ -1,5 +1,5 @@
 #!/usr/bin/env python3
-# Copyright (c) 2020 The DIVI developers
+# 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.
 
@@ -28,7 +28,6 @@ class MnVaultsTest (MnTestFramework):
   def __init__ (self):
     super (MnVaultsTest, self).__init__ ()
     self.base_args = ["-debug=masternode", "-debug=mocktime"]
-    self.cfg = None
     self.number_of_nodes=7
 
   def connect_to_anchors(self,nodeID):
@@ -124,10 +123,10 @@ def fund_vault (self):
     assert_equal (signed["complete"], True)
     self.unvaultTx = signed["hex"]
 
-    self.setup_masternode(2,1,"mn","copper",{"txhash":txid,"vout":vout})
-    self.cfg = self.setup[1].cfg
-    # FIXME: Use reward address from node 0.
-    self.cfg.rewardAddr = addr
+    self.rewardAddr = self.nodes[0].getnewaddress ("reward")
+    self.setup_masternode(2, 1, "mn", "copper",
+                          utxo={"txhash":txid,"vout":vout},
+                          rewardAddr=self.rewardAddr)
     self.stop_masternode_daemons()
     self.start_masternode_daemons(updateMockTime=True)
     self.connect_masternodes_to_peers(range(3,7),updateMockTime=True)
@@ -204,16 +203,21 @@ def get_payments (self):
       self.advance_time (10)
       time.sleep(0.01)
 
+    # Mine some blocks normally to make sure the rewards are mature.
+    self.mine_blocks (20)
+
     # Check that some payments were made.
     winners = self.nodes[3].getmasternodewinners ()
     found = False
     for w in winners:
-      if w["winner"]["address"] == self.cfg.rewardAddr:
+      if w["winner"]["address"] == self.rewardAddr:
         found = True
         break
     assert_equal (found, True)
 
-    # FIXME: Check in wallet when we have a custom reward address.
+    # The payments should have been received at the reward address
+    # and in particular not be lost in the "destroyed" vault.
+    assert_greater_than (self.nodes[0].getbalance ("reward"), 0)
 
   def unvault (self):
     print ("Unvaulting the funds...")

From 0ee4e566ac37333dc87410fed3294f2b12525adb Mon Sep 17 00:00:00 2001
From: Daniel Kraft <d@domob.eu>
Date: Fri, 16 Oct 2020 15:32:49 +0200
Subject: [PATCH 7/8] 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 |  4 +++-
 divi/src/ForkActivation.h   |  7 +++++++
 divi/src/main.cpp           |  1 +
 divi/src/version.cpp        | 14 ++++++++++----
 4 files changed, 21 insertions(+), 5 deletions(-)

diff --git a/divi/src/ForkActivation.cpp b/divi/src/ForkActivation.cpp
index 66f868f75..8d4aedd64 100644
--- a/divi/src/ForkActivation.cpp
+++ b/divi/src/ForkActivation.cpp
@@ -28,7 +28,9 @@ const std::unordered_map<Fork, int64_t,std::hash<int>> ACTIVATION_TIMES = {
   {Fork::UniformLotteryWinners, unixTimestampForDec31stMidnight},
   /* FIXME: Schedule for a real time.  */
   {Fork::CheckLockTimeVerify, 2000000000},
-  {Fork::DeprecateMasternodes,2000000000}
+  {Fork::DeprecateMasternodes,2000000000},
+  /** FIXME: Set actual time once scheduled.  */
+  {Fork::CustomRewardAddresses, 2000000000},
 };
 
 const std::unordered_set<Fork, std::hash<int>> REQUIRE_BLOCK_INDEX_CONTEXT = {
diff --git a/divi/src/ForkActivation.h b/divi/src/ForkActivation.h
index d1617055c..28c87a709 100644
--- a/divi/src/ForkActivation.h
+++ b/divi/src/ForkActivation.h
@@ -24,6 +24,13 @@ enum Fork
   UniformLotteryWinners,
   CheckLockTimeVerify,
   DeprecateMasternodes,
+
+  /**
+   * 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 e2b567b3c..300780028 100755
--- a/divi/src/main.cpp
+++ b/divi/src/main.cpp
@@ -22,6 +22,7 @@
 #include "coins.h"
 #include <defaultValues.h>
 #include "FeeRate.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 358a04448..f80123ea8 100644
--- a/divi/src/version.cpp
+++ b/divi/src/version.cpp
@@ -1,14 +1,13 @@
 #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"))
@@ -19,5 +18,12 @@ int ActiveProtocol()
     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 d9ee191dcfe0898981dc7a1409b61b59cf073adb Mon Sep 17 00:00:00 2001
From: Daniel Kraft <d@domob.eu>
Date: Tue, 16 Feb 2021 14:52:16 +0100
Subject: [PATCH 8/8] 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 | 141 +++++++++++++++++++++
 divi/qa/rpc-tests/masternode.py            |   8 +-
 divi/qa/rpc-tests/test_runner.py           |   1 +
 3 files changed, 149 insertions(+), 1 deletion(-)
 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..a37711305
--- /dev/null
+++ b/divi/qa/rpc-tests/custom_address_update.py
@@ -0,0 +1,141 @@
+#!/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 copy
+import time
+
+OLD_PROTOCOL = 70915
+NEW_PROTOCOL = 71000
+
+
+class CustomAddressUpdateTest (MnTestFramework):
+
+  def __init__ (self):
+    super ().__init__ ()
+    self.base_args = ["-debug", "-nolistenonion", "-activeversion=%d" % OLD_PROTOCOL]
+    self.number_of_nodes = 5
+
+  def args_for (self, n):
+    res = copy.deepcopy (self.base_args)
+    if n == 1:
+      res.extend (["-protocolversion=%d" % OLD_PROTOCOL])
+    return res
+
+  def setup_network (self, config_line=None, extra_args=[]):
+    self.nodes = [
+      start_node (i, self.options.tmpdir, extra_args=self.args_for (i))
+      for i in range (self.number_of_nodes)
+    ]
+    self.setup = [None] * self.number_of_nodes
+
+    # 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 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)
+
+    self.setup_masternode (0, 0, "mn1", "copper")
+    self.setup_masternode (1, 1, "mn2", "copper")
+    self.mine_blocks (15)
+    set_node_times (self.nodes, self.time)
+    self.mine_blocks (1)
+
+  def start_masternodes (self):
+    print ("Starting masternodes...")
+
+    self.stop_masternode_daemons ()
+    self.start_masternode_daemons ()
+    self.connect_masternodes_to_peers ([2, 3, 4], updateMockTime=True)
+
+    # Start the masternodes after the nodes are back up and connected
+    # (so they will receive each other's broadcast).
+    assert_equal (self.broadcast_start ("mn1", True)["status"], "success")
+    assert_equal (self.broadcast_start ("mn2", True)["status"], "success")
+
+    # Check status of the masternodes themselves.
+    self.wait_for_masternodes_to_be_locally_active (updateMockTime=True)
+
+    # Both masternodes should see each other, independent of the
+    # protocol version used.
+    def sortByTxhash (entry):
+      return entry["txhash"]
+    lists = [
+      sorted (self.wait_for_mn_list_to_sync (self.nodes[i], 2), key=sortByTxhash)
+      for i in [0, 1]
+    ]
+    assert_equal (lists[0], lists[1])
+
+    lst = lists[0]
+    assert_equal (len (lst), 2)
+    for val in lst:
+      assert_equal (val["tier"], "COPPER")
+      assert_equal (val["status"], "ENABLED")
+
+
+if __name__ == '__main__':
+  CustomAddressUpdateTest ().main ()
diff --git a/divi/qa/rpc-tests/masternode.py b/divi/qa/rpc-tests/masternode.py
index 35786af3d..06135dac4 100644
--- a/divi/qa/rpc-tests/masternode.py
+++ b/divi/qa/rpc-tests/masternode.py
@@ -6,6 +6,7 @@
 
 from test_framework import BitcoinTestFramework
 from util import *
+import copy
 import time
 
 
@@ -171,6 +172,11 @@ def wait_for_mnsync_on_nodes (self, updateMockTime = False):
         else:
           break
 
+  def args_for(self, n):
+    """Returns the arguments to use for node n.  Defaults to the base args
+    but can be overridden as needed."""
+    return copy.deepcopy(self.base_args)
+
   def stop_masternode_daemons(self):
     def stop_masternode(nodeIndex):
       if self.nodes[nodeIndex] is not None:
@@ -185,7 +191,7 @@ def start_masternode(nodeIndex):
       if self.nodes[nodeIndex] is not None:
         assert_equal("WARNING -- overwriting connection","")
       else:
-        args = self.base_args[:]
+        args = self.args_for(nodeIndex)
         conf = self.setup[nodeIndex].cfg
         args.append ("-masternode=%s" % conf.alias)
         self.nodes[nodeIndex] = start_node (nodeIndex, self.options.tmpdir, extra_args=args, mn_config_lines=[conf.line])
diff --git a/divi/qa/rpc-tests/test_runner.py b/divi/qa/rpc-tests/test_runner.py
index 45aeec670..b478a2ce1 100755
--- a/divi/qa/rpc-tests/test_runner.py
+++ b/divi/qa/rpc-tests/test_runner.py
@@ -83,6 +83,7 @@
     'StakingVaultDeactivation.py',
     'StakingVaultSpam.py',
     'StakingVaultRedundancy.py',
+    'custom_address_update.py',
     'forknotify.py',
     'getchaintips.py',
     'httpbasics.py',