Test UTXO hasher in PoSTransactionCreator.

This adds basic unit tests for PoSTransactionCreator, with a fake
environment that allows a real PoSTransactionCreator to create
staking transactions.

In particular, we use that to unit test that it uses the UTXO hasher
of the wallet properly.

Author: domob1812

divi/src/Makefile.test.include

@@ -101,6 +101,7 @@ BITCOIN_TESTS =\
   test/ProofOfStake_tests.cpp \
   test/IsMine_tests.cpp \
   test/PoSStakeModifierService_tests.cpp \
+  test/PoSTransactionCreator_tests.cpp \
   test/LegacyPoSStakeModifierService_tests.cpp \
   test/LotteryWinnersCalculatorTests.cpp \
   test/UtxoCheckingAndUpdating_tests.cpp \

divi/src/ProofOfStakeModule.cpp

@@ -25,4 +25,4 @@ ProofOfStakeModule::~ProofOfStakeModule()
 const I_ProofOfStakeGenerator& ProofOfStakeModule::proofOfStakeGenerator() const
 {
     return *proofGenerator_;
-}
+}

divi/src/ProofOfStakeModule.h

@@ -21,4 +21,4 @@ class ProofOfStakeModule
     ~ProofOfStakeModule();
     const I_ProofOfStakeGenerator& proofOfStakeGenerator() const;
 };
-#endif// PROOF_OF_STAKE_MODULE_H
+#endif// PROOF_OF_STAKE_MODULE_H

divi/src/test/FakeWallet.cpp

@@ -115,6 +115,11 @@ void FakeWallet::AddBlock()
   fakeChain.addBlocks(1, version);
 }
 
+void FakeWallet::AddConfirmations(const unsigned numConf, const int64_t minAge)
+{
+  fakeChain.addBlocks(numConf, version, fakeChain.activeChain->Tip()->nTime + minAge);
+}
+
 const CWalletTx& FakeWallet::AddDefaultTx(const CScript& scriptToPayTo, unsigned& outputIndex,
                                           const CAmount amount)
 {

divi/src/test/FakeWallet.h

@@ -39,6 +39,12 @@ class FakeWallet : public CWallet
   /** Adds a new block to our fake chain.  */
   void AddBlock();
 
+  /** Adds a couple of new blocks and bumps the time at least
+   *  the given amount.  This can be used to make sure some
+   *  coins fake added to the chain have at least a given age
+   *  and number of confirmations.  */
+  void AddConfirmations(unsigned numConf, int64_t minAge = 0);
+
   /** Adds a new ordinary transaction to the wallet, paying a given amount
    *  to a given script.  The transaction is returned, and the output index
    *  with the output to the requested script is set.  */

divi/src/test/PoSTransactionCreator_tests.cpp

@@ -0,0 +1,148 @@
+// Copyright (c) 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.
+
+#include "PoSTransactionCreator.h"
+
+#include "chain.h"
+#include "chainparams.h"
+#include "ProofOfStakeModule.h"
+#include "script/standard.h"
+#include "Settings.h"
+#include "WalletTx.h"
+
+#include "test/FakeBlockIndexChain.h"
+#include "test/FakeWallet.h"
+#include "test/MockBlockIncentivesPopulator.h"
+#include "test/MockBlockSubsidyProvider.h"
+#include "test/MockUtxoHasher.h"
+
+#include <boost/test/unit_test.hpp>
+#include "test/test_only.h"
+
+#include <gmock/gmock.h>
+
+#include <map>
+
+extern Settings& settings;
+
+namespace
+{
+
+using testing::_;
+using testing::AtLeast;
+using testing::Return;
+
+class PoSTransactionCreatorTestFixture
+{
+
+protected:
+
+  FakeBlockIndexWithHashes fakeChain;
+  FakeWallet wallet;
+
+private:
+
+  const CChainParams& chainParams;
+
+  MockBlockIncentivesPopulator blockIncentivesPopulator;
+  MockBlockSubsidyProvider blockSubsidyProvider;
+  ProofOfStakeModule posModule;
+
+  std::map<unsigned, unsigned> hashedBlockTimestamps;
+
+  PoSTransactionCreator txCreator;
+
+protected:
+
+  /** A script from the wallet for convenience.  */
+  const CScript walletScript;
+
+  /** UTXO hasher used in the wallet.  The instance is owned by the wallet,
+   *  and a reference is kept here.  */
+  MockUtxoHasher* utxoHasher;
+
+  /* Convenience variables for tests to use in calls to CreatePoS.  */
+  CMutableTransaction mtx;
+  unsigned txTime;
+
+  /* Convenience variable for the wallet's AddDefaultTx.  */
+  unsigned outputIndex;
+
+  PoSTransactionCreatorTestFixture()
+    : fakeChain(1, 1600000000, 1),
+      wallet(fakeChain),
+      chainParams(Params(CBaseChainParams::REGTEST)),
+      posModule(chainParams, *fakeChain.activeChain, *fakeChain.blockIndexByHash),
+      txCreator(settings, chainParams, *fakeChain.activeChain, *fakeChain.blockIndexByHash,
+                blockSubsidyProvider, blockIncentivesPopulator,
+                posModule.proofOfStakeGenerator(), wallet, hashedBlockTimestamps),
+      walletScript(GetScriptForDestination(wallet.getNewKey().GetID()))
+  {
+    std::unique_ptr<MockUtxoHasher> hasher(new MockUtxoHasher());
+    utxoHasher = hasher.get();
+    wallet.SetUtxoHasherForTesting(std::move (hasher));
+
+    /* Set up a default block reward if we don't need anything else.  */
+    EXPECT_CALL(blockSubsidyProvider, GetFullBlockValue(_))
+        .WillRepeatedly(Return(11 * COIN));
+    EXPECT_CALL(blockSubsidyProvider, GetBlockSubsidity(_))
+        .WillRepeatedly(Return(CBlockRewards(10 * COIN, COIN, 0, 0, 0, 0)));
+
+    /* We don't care about the block payments.  */
+    EXPECT_CALL(blockIncentivesPopulator, FillBlockPayee(_, _, _, _)).Times(AtLeast(0));
+    EXPECT_CALL(blockIncentivesPopulator, IsBlockValueValid(_, _, _))
+        .WillRepeatedly(Return(true));
+    EXPECT_CALL(blockIncentivesPopulator, HasValidPayees(_, _))
+        .WillRepeatedly(Return(true));
+  }
+
+  /** Calls CreateProofOfStake on our PoSTransactionCreator with the
+   *  fake wallet's chain tip and regtest difficulty.  */
+  bool CreatePoS(CMutableTransaction& txCoinStake, unsigned& nTxNewTime)
+  {
+    return txCreator.CreateProofOfStake(fakeChain.activeChain->Tip(), 0x207fffff, txCoinStake, nTxNewTime);
+  }
+
+  bool CreatePoS()
+  {
+    return CreatePoS(mtx, txTime);
+  }
+
+};
+
+BOOST_FIXTURE_TEST_SUITE(PoSTransactionCreator_tests, PoSTransactionCreatorTestFixture)
+
+BOOST_AUTO_TEST_CASE(failsWithoutCoinsInWallet)
+{
+  BOOST_CHECK(!CreatePoS());
+}
+
+BOOST_AUTO_TEST_CASE(checksForConfirmationsAndAge)
+{
+  const auto& tx = wallet.AddDefaultTx(walletScript, outputIndex, 1000 * COIN);
+  wallet.FakeAddToChain(tx);
+
+  BOOST_CHECK(!CreatePoS());
+
+  wallet.AddConfirmations(20, 1000);
+  BOOST_CHECK(CreatePoS());
+}
+
+BOOST_AUTO_TEST_CASE(usesUtxoHashForInputs)
+{
+  const auto& tx = wallet.AddDefaultTx(walletScript, outputIndex, 1000 * COIN);
+  wallet.FakeAddToChain(tx);
+  wallet.AddConfirmations(20, 1000);
+
+  const auto hash = utxoHasher->Add(tx);
+  BOOST_CHECK(CreatePoS());
+
+  BOOST_CHECK_EQUAL(mtx.vin.size(), 1);
+  BOOST_CHECK_EQUAL(mtx.vin[0].prevout.n, outputIndex);
+  BOOST_CHECK(mtx.vin[0].prevout.hash == hash);
+}
+
+BOOST_AUTO_TEST_SUITE_END()
+
+} // anonymous namespace

divi/src/wallet.cpp

@@ -2341,6 +2341,11 @@ uint256 CWallet::GetUtxoHash(const CMerkleTx& tx) const
     return utxoHasher->GetUtxoHash(tx);
 }
 
+void CWallet::SetUtxoHasherForTesting(std::unique_ptr<TransactionUtxoHasher> hasher)
+{
+    utxoHasher = std::move(hasher);
+}
+
 DBErrors CWallet::LoadWallet(bool& fFirstRunRet)
 {
     if (!fFileBacked)

divi/src/wallet.h

@@ -228,6 +228,9 @@ class CWallet : public CCryptoKeyStore, public NotificationInterface, public I_K
      *  from the given transaction (which should be part of the wallet).  */
     uint256 GetUtxoHash(const CMerkleTx& tx) const;
 
+    /** Replaces the UTXO hasher used in the wallet, for testing purposes.  */
+    void SetUtxoHasherForTesting(std::unique_ptr<TransactionUtxoHasher> hasher);
+
     //  keystore implementation
     // Generate a new key
     CPubKey GenerateNewKey(uint32_t nAccountIndex, bool fInternal);