mandatory, voting: Implement poll type validation in protocol

src/chainparams.cpp

@@ -66,6 +66,7 @@ class CMainParams : public CChainParams {
         consensus.BlockV10Height = 1420000;
         consensus.BlockV11Height = 2053000;
         consensus.BlockV12Height = std::numeric_limits<int>::max();
+        consensus.PollV3Height = std::numeric_limits<int>::max();
         // Immediately post zero payment interval fees 40% for mainnet
         consensus.InitialMRCFeeFractionPostZeroInterval = Fraction(2, 5);
         // Zero day interval is 14 days on mainnet
@@ -160,6 +161,7 @@ class CTestNetParams : public CChainParams {
         consensus.BlockV10Height = 629409;
         consensus.BlockV11Height = 1301500;
         consensus.BlockV12Height = 1871830;
+        consensus.PollV3Height = 1944820;
         // Immediately post zero payment interval fees 40% for testnet, the same as mainnet
         consensus.InitialMRCFeeFractionPostZeroInterval = Fraction(2, 5);
         // Zero day interval is 10 minutes on testnet. The very short interval facilitates testing.

src/chainparams.h

@@ -150,6 +150,14 @@ inline bool IsV12Enabled(int nHeight)
     return nHeight >= BlockV12Height;
 }
 
+inline bool IsPollV3Enabled(int nHeight)
+{
+    // Temporary override for testing. Cf. Corresponding code in init.cpp
+    int PollV3Height = gArgs.GetArg("-pollv3height", Params().GetConsensus().PollV3Height);
+
+    return nHeight >= PollV3Height;
+}
+
 inline int GetSuperblockAgeSpacing(int nHeight)
 {
     return (fTestNet ? 86400 : (nHeight > 364500) ? 86400 : 43200);

src/consensus/params.h

@@ -33,6 +33,8 @@ struct Params {
     int BlockV11Height;
     /** Block height at which v12 blocks are created */
     int BlockV12Height;
+    /** Block height at which poll v3 contract payloads are valid */
+    int PollV3Height;
     /** The fraction of rewards taken as fees in an MRC after the zero payment interval. Only consesnus critical
       * at BlockV12Height or above.
       */

src/gridcoin/beacon.cpp

@@ -817,6 +817,11 @@ bool BeaconRegistry::Validate(const Contract& contract, const CTransaction& tx,
     return true;
 }
 
+bool BeaconRegistry::BlockValidate(const ContractContext& ctx, int& DoS) const
+{
+    return Validate(ctx.m_contract, ctx.m_tx, DoS);
+}
+
 void BeaconRegistry::ActivatePending(
     const std::vector<uint160>& beacon_ids,
     const int64_t superblock_time, const uint256& block_hash, const int& height)

src/gridcoin/beacon.h

@@ -619,6 +619,17 @@ class BeaconRegistry : public IContractHandler
     //!
     bool Validate(const Contract& contract, const CTransaction& tx, int &DoS) const override;
 
+    //!
+    //! \brief Determine whether a beacon contract is valid including block context. This is used
+    //! in ConnectBlock.
+    //!
+    //! \param ctx ContractContext containing the beacon data to validate.
+    //! \param DoS Misbehavior score out.
+    //!
+    //! \return  \c false If the contract fails validation.
+    //!
+    bool BlockValidate(const ContractContext& ctx, int& DoS) const override;
+
     //!
     //! \brief Register a beacon from contract data.
     //!

src/gridcoin/contract/contract.cpp

@@ -163,6 +163,11 @@ class AppCacheContractHandler : public IContractHandler
         return true; // No contextual validation needed yet
     }
 
+    bool BlockValidate(const ContractContext& ctx, int& DoS) const override
+    {
+        return true; // No contextual validation needed yet
+    }
+
     void Add(const ContractContext& ctx) override
     {
         const auto payload = ctx->SharePayloadAs<LegacyPayload>();
@@ -200,6 +205,11 @@ class UnknownContractHandler : public IContractHandler
         return true; // No contextual validation needed yet
     }
 
+    bool BlockValidate(const ContractContext& ctx, int& DoS) const override
+    {
+        return true; // No contextual validation needed yet
+    }
+
     //!
     //! \brief Handle a contract addition.
     //!
@@ -288,6 +298,28 @@ class Dispatcher
         return GetHandler(contract.m_type.Value()).Validate(contract, tx, DoS);
     }
 
+    //!
+    //! \brief Perform contextual validation for the provided contract including block context. This is used
+    //! in ConnectBlock.
+    //!
+    //! \param ctx ContractContext to validate.
+    //! \param DoS Misbehavior score out.
+    //!
+    //! \return \c false If the contract fails validation.
+    //!
+    bool BlockValidate(const ContractContext& ctx, int& DoS)
+    {
+        if (!GetHandler(ctx.m_contract.m_type.Value()).BlockValidate(ctx, DoS)) {
+            error("%s: Contract of type %s failed validation.",
+                  __func__,
+                  ctx.m_contract.m_type.ToString());
+
+            return false;
+        }
+
+        return true;
+    }
+
     //!
     //! \brief Revert a previously-applied contract from a transaction message
     //! by passing it to the appropriate contract handler.
@@ -604,6 +636,17 @@ bool GRC::ValidateContracts(const CTransaction& tx, int& DoS)
     return true;
 }
 
+bool GRC::BlockValidateContracts(const CBlockIndex* const pindex, const CTransaction& tx, int& DoS)
+{
+    for (const auto& contract: tx.GetContracts()) {
+        if (!g_dispatcher.BlockValidate({ contract, tx, pindex }, DoS)) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
 void GRC::RevertContracts(const CTransaction& tx, const CBlockIndex* const pindex)
 {
     // Reverse the contracts. Reorganize will load any previous versions:
@@ -896,7 +939,11 @@ void Contract::Body::ResetType(const ContractType type)
             m_payload.Reset(new TxMessage());
             break;
         case ContractType::POLL:
-            m_payload.Reset(new PollPayload());
+            // Note that the contract code expects cs_main to already be taken which
+            // means that the access to nBestHeight is safe.
+            // TODO: This ternary should be removed at the next mandatory after
+            // Kermit's Mom.
+            m_payload.Reset(new PollPayload(IsPollV3Enabled(nBestHeight) ? 3 : 2));
             break;
         case ContractType::PROJECT:
             m_payload.Reset(new Project());

src/gridcoin/contract/contract.h

@@ -6,6 +6,7 @@
 #define GRIDCOIN_CONTRACT_CONTRACT_H
 
 #include "amount.h"
+#include "gridcoin/contract/handler.h"
 #include "gridcoin/contract/payload.h"
 #include "gridcoin/support/enumbytes.h"
 #include "serialize.h"
@@ -520,6 +521,18 @@ void ApplyContracts(
 //!
 bool ValidateContracts(const CTransaction& tx, int& DoS);
 
+//!
+//! \brief Perform contextual validation for the contracts in a transaction including block context. This is used
+//! in ConnectBlock.
+//!
+//! \param pindex The CBlockIndex of the block context of the transaction.
+//! \param tx The transaction to validate contracts for.
+//! \param DoS Misbehavior score out.
+//!
+//! \return  \c false If the contract fails validation.
+//!
+bool BlockValidateContracts(const CBlockIndex* const pindex, const CTransaction& tx, int& DoS);
+
 //!
 //! \brief Revert previously-applied contracts from a transaction by passing
 //! them to the appropriate contract handlers.

src/gridcoin/contract/handler.h

@@ -83,6 +83,17 @@ struct IContractHandler
     //!
     virtual bool Validate(const Contract& contract, const CTransaction& tx, int& DoS) const = 0;
 
+    //!
+    //! \brief Perform contextual validation for the provided contract including block context. This is used
+    //! in ConnectBlock.
+    //!
+    //! \param ctx ContractContext to validate.
+    //! \param DoS Misbehavior score out.
+    //!
+    //! \return  \c false If the contract fails validation.
+    //!
+    virtual bool BlockValidate(const ContractContext& ctx, int& DoS) const = 0;
+
     //!
     //! \brief Destroy the contract handler state to prepare for historical
     //! contract replay.

src/gridcoin/mrc.cpp

@@ -207,6 +207,11 @@ bool GRC::MRCContractHandler::Validate(const Contract& contract, const CTransact
     return ValidateMRC(contract, tx, DoS);
 }
 
+bool GRC::MRCContractHandler::BlockValidate(const ContractContext& ctx, int& DoS) const
+{
+    return Validate(ctx.m_contract, ctx.m_tx, DoS);
+}
+
 namespace {
 //!
 //! \brief Sign the mrc.

src/gridcoin/mrc.h

@@ -322,8 +322,28 @@ class MRCContractHandler : public IContractHandler
     // Reset is a noop for MRC's here.
     void Reset() override {}
 
+    //!
+    //! \brief Perform contextual validation for the provided contract.
+    //!
+    //! \param contract Contract to validate.
+    //! \param tx       Transaction that contains the contract.
+    //! \param DoS      Misbehavior score out.
+    //!
+    //! \return \c false If the contract fails validation.
+    //!
     bool Validate(const Contract& contract, const CTransaction& tx, int& DoS) const override;
 
+    //!
+    //! \brief Perform contextual validation for the provided contract including block context. This is used
+    //! in ConnectBlock.
+    //!
+    //! \param ctx ContractContext to validate.
+    //! \param DoS Misbehavior score out.
+    //!
+    //! \return  \c false If the contract fails validation.
+    //!
+    bool BlockValidate(const ContractContext& ctx, int& DoS) const override;
+
     // Add is a noop here, because this is handled at the block level by the staker (in the miner) as with the claim.
     void Add(const ContractContext& ctx) override {}
 

src/gridcoin/project.h

@@ -306,6 +306,20 @@ class Whitelist : public IContractHandler
         return true; // No contextual validation needed yet
     }
 
+    //!
+    //! \brief Perform contextual validation for the provided contract including block context. This is used
+    //! in ConnectBlock.
+    //!
+    //! \param ctx ContractContext to validate.
+    //! \param DoS Misbehavior score out.
+    //!
+    //! \return \c false If the contract fails validation.
+    //!
+    bool BlockValidate(const ContractContext& ctx, int& DoS) const override
+    {
+        return true; // No contextual validation needed yet
+    }
+
     //!
     //! \brief Add a project to the whitelist from contract data.
     //!

src/gridcoin/support/block_finder.cpp

@@ -18,12 +18,14 @@ CBlockIndex* BlockFinder::FindByHeight(int height)
     if(index != nullptr)
     {
         // Traverse towards the tail.
-        while (index && index->pprev && index->nHeight > height)
+        while (index && index->pprev && index->nHeight > height) {
             index = index->pprev;
+        }
 
         // Traverse towards the head.
-        while (index && index->pnext && index->nHeight < height)
+        while (index && index->pnext && index->nHeight < height) {
             index = index->pnext;
+        }
     }
 
     return index;
@@ -38,15 +40,33 @@ CBlockIndex* BlockFinder::FindByMinTime(int64_t time)
             ? pindexBest
             : pindexGenesisBlock;
 
-    if(index != nullptr)
+    if (index != nullptr)
     {
         // Move back until the previous block is no longer younger than "time".
-        while(index && index->pprev && index->pprev->nTime > time)
+        while (index && index->pprev && index->pprev->nTime > time) {
             index = index->pprev;
+        }
 
         // Move forward until the current block is younger than "time".
-        while(index && index->pnext && index->nTime < time)
+        while (index && index->pnext && index->nTime < time) {
             index = index->pnext;
+        }
+    }
+
+    return index;
+}
+
+// The arguments are passed by value on purpose.
+CBlockIndex* BlockFinder::FindByMinTimeFromGivenIndex(int64_t time, CBlockIndex* index)
+{
+    // If no starting index is provided (i.e. second parameter is omitted or nullptr is passed in,
+    // then start at the Genesis Block. This is in general expensive and should be avoided.
+    if (!index) {
+        index = pindexGenesisBlock;
+    }
+
+    while (index && index->pnext && index->nTime < time) {
+        index = index->pnext;
     }
 
     return index;

src/gridcoin/support/block_finder.h

@@ -5,6 +5,8 @@
 #ifndef GRIDCOIN_SUPPORT_BLOCK_FINDER_H
 #define GRIDCOIN_SUPPORT_BLOCK_FINDER_H
 
+#include <cstdint>
+
 class CBlockIndex;
 
 namespace GRC {
@@ -38,6 +40,15 @@ class BlockFinder
     //! head of the chain if it is older than \p time.
     //!
     static CBlockIndex* FindByMinTime(int64_t time);
+
+    //!
+    //! \brief Find block by time going forward from given index.
+    //! \param time
+    //! \param CBlockIndex from where to start
+    //! \return CBlockIndex pointing to the youngest block which is not older than \p time, or
+    //! the head of the chain if it is older than \p time.
+    //!
+    static CBlockIndex* FindByMinTimeFromGivenIndex(int64_t time, CBlockIndex* index = nullptr);
 };
 } // namespace GRC