Consensus and mempool parts of segwit-light.

This implements "segwit-light" in the node (consensus and mempool):
After activation of a new fork, outputs created by new transactions
are referred to by the creating transaction's bare txid rather than
the normal hash (txid).  This makes chains of constructed transactions
immune to transaction malleability.

In the mempool, we use the current chain tip to determine the activation
state of the fork, as we can't know for sure when a transaction will be
confirmed (and thus what activation state will be in effect then).  This
will lead to issues right around the fork activation time, but we will
simply disallow spending of unconfirmed outputs in the mempool and
wallet "around" the fork time temporarily to resolve this.

The wallet is also not yet updated to take the change into account
when selecting coins.

Author: domob1812

divi/src/ActiveChainManager.cpp

@@ -5,6 +5,7 @@
 #include <chain.h>
 #include <coins.h>
 #include <BlockUndo.h>
+#include <ForkActivation.h>
 #include <Logging.h>
 #include <addressindex.h>
 #include <txdb.h>
@@ -87,7 +88,8 @@ bool ActiveChainManager::DisconnectBlock(
         return error("DisconnectBlock() : block and undo data inconsistent");
     }
 
-    const BlockUtxoHasher utxoHasher;
+    const ActivationState as(pindex);
+    const BlockUtxoHasher utxoHasher(as);
 
     bool fClean = true;
     IndexDatabaseUpdates indexDBUpdates;

divi/src/ForkActivation.cpp

@@ -27,12 +27,15 @@ const std::unordered_map<Fork, int64_t,std::hash<int>> ACTIVATION_TIMES = {
   {Fork::UniformLotteryWinners, unixTimestampForDec31stMidnight},
   /* FIXME: Schedule for a real time.  */
   {Fork::CheckLockTimeVerify, 2000000000},
+  /* FIXME: Set real activation time for segwit light.  It is after
+     staking vaults.  */
+  {Fork::SegwitLight, 2100000000},
 };
 
 } // anonymous namespace
 
 ActivationState::ActivationState(const CBlockIndex* pi)
-  : nTime(pi->nTime)
+  : nTime(pi == nullptr ? 0 : pi->nTime)
 {}
 
 ActivationState::ActivationState(const CBlockHeader& block)

divi/src/ForkActivation.h

@@ -18,11 +18,19 @@ class CBlockIndex;
  */
 enum Fork
 {
-  /* Test forks not actually deployed / active but used for unit tests.  */
-  TestByTimestamp,
   HardenedStakeModifier,
   UniformLotteryWinners,
   CheckLockTimeVerify,
+
+  /**
+   * Start of "segwit light":  The UTXOs created by transactions from after
+   * the fork will be indexed by a "bare txid", which does not include
+   * any signature data.  This fixes transaction malleability.
+   */
+  SegwitLight,
+
+  /* Test forks not actually deployed / active but used for unit tests.  */
+  TestByTimestamp,
 };
 
 /**

divi/src/UtxoCheckingAndUpdating.cpp

@@ -1,5 +1,6 @@
 #include <UtxoCheckingAndUpdating.h>
 
+#include <ForkActivation.h>
 #include <primitives/transaction.h>
 #include <Logging.h>
 #include <coins.h>
@@ -14,6 +15,8 @@
 
 OutputHash BlockUtxoHasher::GetUtxoHash(const CTransaction& tx) const
 {
+    if (as.IsActive(Fork::SegwitLight))
+        return OutputHash(tx.GetBareTxid());
     return OutputHash(tx.GetHash());
 }
 

divi/src/UtxoCheckingAndUpdating.h

@@ -7,6 +7,7 @@
 #include <amount.h>
 #include <uint256.h>
 
+class ActivationState;
 class BlockMap;
 class CTransaction;
 class CValidationState;
@@ -56,8 +57,17 @@ class TransactionUtxoHasher
 class BlockUtxoHasher : public TransactionUtxoHasher
 {
 
+private:
+
+  /** The activation state used for checking on segwit light.  */
+  const ActivationState& as;
+
 public:
 
+  explicit BlockUtxoHasher(const ActivationState& a)
+    : as(a)
+  {}
+
   OutputHash GetUtxoHash(const CTransaction& tx) const override;
 
 };

divi/src/main.cpp

@@ -21,6 +21,7 @@
 #include "coins.h"
 #include <defaultValues.h>
 #include "FeeRate.h"
+#include "ForkActivation.h"
 #include "init.h"
 #include "kernel.h"
 #include "libzerocoin/bignum.h"
@@ -1056,7 +1057,8 @@ bool ConnectBlock(const CBlock& block, CValidationState& state, CBlockIndex* pin
     LogWalletBalance();
     static const CChainParams& chainParameters = Params();
 
-    const BlockUtxoHasher utxoHasher;
+    const ActivationState as(block);
+    const BlockUtxoHasher utxoHasher(as);
 
     VerifyBestBlockIsAtPreviousBlock(pindex,view);
     if (block.GetHash() == Params().HashGenesisBlock())
@@ -2327,7 +2329,8 @@ bool static LoadBlockIndexDB(string& strError)
                     strError = "The wallet has been not been closed gracefully and has caused corruption of blocks stored to disk. Data directory is in an unusable state";
                     return false;
                 }
-                const BlockUtxoHasher utxoHasher;
+                const ActivationState as(block);
+                const BlockUtxoHasher utxoHasher(as);
 
                 std::vector<CTxUndo> vtxundo;
                 vtxundo.reserve(block.vtx.size() - 1);

divi/src/rpcblockchain.cpp

@@ -415,7 +415,7 @@ Value gettxout(const Array& params, bool fHelp)
             "gettxout \"txid\" n ( includemempool )\n"
             "\nReturns details about an unspent transaction output.\n"
             "\nArguments:\n"
-            "1. \"txid\"       (string, required) The transaction id\n"
+            "1. \"txid\"       (string, required) The transaction id or bare txid (after segwit-light)\n"
             "2. n              (numeric, required) vout value\n"
             "3. includemempool  (boolean, optional) Whether to included the mem pool\n"
             "\nResult:\n"

divi/src/test/wallet_coinmanagement_tests.cpp

@@ -453,9 +453,7 @@ BOOST_AUTO_TEST_CASE(willUseUtxoHashForSpendingCoins)
     wallet.FakeAddToChain(wtx);
 
     const CScript sendTo = CScript() << OP_TRUE;
-    std::string strError;
     CReserveKey reserveKey(wallet);
-    CAmount nFeeRequired;
     CWalletTx wtxNew;
     BOOST_CHECK(wallet.CreateTransaction({{sendTo, COIN / 10}}, wtxNew, reserveKey, ALL_SPENDABLE_COINS, nullptr).second);
 

divi/src/txmempool.cpp

@@ -7,6 +7,7 @@
 #include "txmempool.h"
 
 #include "clientversion.h"
+#include "ForkActivation.h"
 #include "main.h"
 #include "streams.h"
 #include "Logging.h"
@@ -363,14 +364,21 @@ class CMinerPolicyEstimator
 namespace
 {
 
-/** The UTXO hasher used in mempool logic.  */
+/** The UTXO hasher used in mempool logic.  It uses the state of segwit-light
+ *  based on the latest chain tip (since we can't know when a particular
+ *  transaction will be confirmed / what the real activation state will be then).
+ *  Spending of unconfirmed change around the fork will be discouraged by
+ *  policy, so that this should not be an issue in practice.  */
 class MempoolUtxoHasher : public TransactionUtxoHasher
 {
 
 public:
 
   OutputHash GetUtxoHash(const CTransaction& tx) const override
   {
+      const ActivationState as(chainActive.Tip());
+      if (as.IsActive(Fork::SegwitLight))
+          return OutputHash(tx.GetBareTxid());
       return OutputHash(tx.GetHash());
   }