LCOV - code coverage report
Current view: top level - src/consensus - params.h (source / functions) Hit Total Coverage
Test: total_coverage.info Lines: 14 24 58.3 %
Date: 2025-02-23 09:33:43 Functions: 1 2 50.0 %

          Line data    Source code
       1             : // Copyright (c) 2009-2010 Satoshi Nakamoto
       2             : // Copyright (c) 2009-2016 The Bitcoin Core developers
       3             : // Distributed under the MIT software license, see the accompanying
       4             : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
       5             : 
       6             : #ifndef PIVX_CONSENSUS_PARAMS_H
       7             : #define PIVX_CONSENSUS_PARAMS_H
       8             : 
       9             : #include "amount.h"
      10             : #include "libzerocoin/Params.h"
      11             : #include "optional.h"
      12             : #include "uint256.h"
      13             : #include <map>
      14             : #include <string>
      15             : 
      16             : namespace Consensus {
      17             : 
      18             : /**
      19             : * Index into Params.vUpgrades and NetworkUpgradeInfo
      20             : *
      21             : * Being array indices, these MUST be numbered consecutively.
      22             : *
      23             : * The order of these indices MUST match the order of the upgrades on-chain, as
      24             : * several functions depend on the enum being sorted.
      25             : */
      26             : enum UpgradeIndex : uint32_t {
      27             :     BASE_NETWORK,
      28             :     UPGRADE_POS,
      29             :     UPGRADE_POS_V2,
      30             :     UPGRADE_ZC,
      31             :     UPGRADE_ZC_V2,
      32             :     UPGRADE_BIP65,
      33             :     UPGRADE_ZC_PUBLIC,
      34             :     UPGRADE_V3_4,
      35             :     UPGRADE_V4_0,
      36             :     UPGRADE_V5_0,
      37             :     UPGRADE_V5_2,
      38             :     UPGRADE_V5_3,
      39             :     UPGRADE_V5_5,
      40             :     UPGRADE_V5_6,
      41             :     UPGRADE_V6_0,
      42             :     UPGRADE_TESTDUMMY,
      43             :     // NOTE: Also add new upgrades to NetworkUpgradeInfo in upgrades.cpp
      44             :     MAX_NETWORK_UPGRADES
      45             : };
      46             : 
      47             : struct NetworkUpgrade {
      48             :     /**
      49             :      * The first protocol version which will understand the new consensus rules
      50             :      */
      51             :     int nProtocolVersion;
      52             : 
      53             :     /**
      54             :      * Height of the first block for which the new consensus rules will be active
      55             :      */
      56             :     int nActivationHeight;
      57             : 
      58             :     /**
      59             :      * Special value for nActivationHeight indicating that the upgrade is always active.
      60             :      * This is useful for testing, as it means tests don't need to deal with the activation
      61             :      * process (namely, faking a chain of somewhat-arbitrary length).
      62             :      *
      63             :      * New blockchains that want to enable upgrade rules from the beginning can also use
      64             :      * this value. However, additional care must be taken to ensure the genesis block
      65             :      * satisfies the enabled rules.
      66             :      */
      67             :     static constexpr int ALWAYS_ACTIVE = 0;
      68             : 
      69             :     /**
      70             :      * Special value for nActivationHeight indicating that the upgrade will never activate.
      71             :      * This is useful when adding upgrade code that has a testnet activation height, but
      72             :      * should remain disabled on mainnet.
      73             :      */
      74             :     static constexpr int NO_ACTIVATION_HEIGHT = -1;
      75             : 
      76             :     /**
      77             :      * The hash of the block at height nActivationHeight, if known. This is set manually
      78             :      * after a network upgrade activates.
      79             :      *
      80             :      * We use this in IsInitialBlockDownload to detect whether we are potentially being
      81             :      * fed a fake alternate chain. We use NU activation blocks for this purpose instead of
      82             :      * the checkpoint blocks, because network upgrades (should) have significantly more
      83             :      * scrutiny than regular releases. nMinimumChainWork MUST be set to at least the chain
      84             :      * work of this block, otherwise this detection will have false positives.
      85             :      */
      86             :     Optional<uint256> hashActivationBlock;
      87             : };
      88             : 
      89             : enum LLMQType : uint8_t
      90             : {
      91             :     LLMQ_NONE = 0xff,
      92             : 
      93             :     LLMQ_50_60 = 1, // 50 members, 30 (60%) threshold, one per hour
      94             :     LLMQ_400_60 = 2, // 400 members, 240 (60%) threshold, one every 12 hours
      95             :     LLMQ_400_85 = 3, // 400 members, 340 (85%) threshold, one every 24 hours
      96             : 
      97             :     // for testing only
      98             :     LLMQ_TEST = 100, // 3 members, 2 (66%) threshold, one per hour. Params might differ when -llmqtestparams is used
      99             : };
     100             : 
     101             : // Configures a LLMQ and its DKG
     102             : // See https://github.com/dashpay/dips/blob/master/dip-0006.md for more details
     103       11522 : struct LLMQParams {
     104             :     LLMQType type;
     105             : 
     106             :     // not consensus critical, only used in logging, RPC and UI
     107             :     std::string name;
     108             : 
     109             :     // the size of the quorum, e.g. 50 or 400
     110             :     int size;
     111             : 
     112             :     // The minimum number of valid members after the DKK. If less members are determined valid, no commitment can be
     113             :     // created. Should be higher then the threshold to allow some room for failing nodes, otherwise quorum might end up
     114             :     // not being able to ever created a recovered signature if more nodes fail after the DKG
     115             :     int minSize;
     116             : 
     117             :     // The threshold required to recover a final signature. Should be at least 50%+1 of the quorum size. This value
     118             :     // also controls the size of the public key verification vector and has a large influence on the performance of
     119             :     // recovery. It also influences the amount of minimum messages that need to be exchanged for a single signing session.
     120             :     // This value has the most influence on the security of the quorum. The number of total malicious masternodes
     121             :     // required to negatively influence signing sessions highly correlates to the threshold percentage.
     122             :     int threshold;
     123             : 
     124             :     // The interval in number blocks for DKGs and the creation of LLMQs. If set to 60 for example, a DKG will start
     125             :     // every 60 blocks, which is approximately once every hour.
     126             :     int dkgInterval;
     127             : 
     128             :     // The number of blocks per phase in a DKG session. There are 6 phases plus the mining phase that need to be processed
     129             :     // per DKG. Set this value to a number of blocks so that each phase has enough time to propagate all required
     130             :     // messages to all members before the next phase starts. If blocks are produced too fast, whole DKG sessions will
     131             :     // fail.
     132             :     int dkgPhaseBlocks;
     133             : 
     134             :     // The starting block inside the DKG interval for when mining of commitments starts. The value is inclusive.
     135             :     // Starting from this block, the inclusion of (possibly null) commitments is enforced until the first non-null
     136             :     // commitment is mined. The chosen value should be at least 5 * dkgPhaseBlocks so that it starts right after the
     137             :     // finalization phase.
     138             :     int dkgMiningWindowStart;
     139             : 
     140             :     // The ending block inside the DKG interval for when mining of commitments ends. The value is inclusive.
     141             :     // Choose a value so that miners have enough time to receive the commitment and mine it. Also take into consideration
     142             :     // that miners might omit real commitments and revert to always including null commitments. The mining window should
     143             :     // be large enough so that other miners have a chance to produce a block containing a non-null commitment. The window
     144             :     // should at the same time not be too large so that not too much space is wasted with null commitments in case a DKG
     145             :     // session failed.
     146             :     int dkgMiningWindowEnd;
     147             : 
     148             :     // In the complaint phase, members will vote on other members being bad (missing valid contribution). If at least
     149             :     // dkgBadVotesThreshold have voted for another member to be bad, it will considered to be bad by all other members
     150             :     // as well. This serves as a protection against late-comers who send their contribution on the bring of
     151             :     // phase-transition, which would otherwise result in inconsistent views of the valid members set
     152             :     int dkgBadVotesThreshold;
     153             : 
     154             :     // Number of quorums to consider "active" for signing sessions
     155             :     int signingActiveQuorumCount;
     156             : 
     157             :     // Used for intra-quorum communication. This is the number of quorums for which we should keep old connections. This
     158             :     // should be at least one more then the active quorums set.
     159             :     int keepOldConnections;
     160             : 
     161             :     // How many members should we try to send all sigShares to before we give up.
     162             :     int recoveryMembers;
     163             : 
     164             :     // The limit of blocks up until where the dkg qfc will be accepted.
     165             :     int cacheDkgInterval;
     166             : };
     167             : 
     168             : /**
     169             :  * Parameters that influence chain consensus.
     170             :  */
     171             : struct Params {
     172             :     uint256 hashGenesisBlock;
     173             :     bool fPowAllowMinDifficultyBlocks;
     174             :     bool fPowNoRetargeting;
     175             :     uint256 powLimit;
     176             :     uint256 posLimitV1;
     177             :     uint256 posLimitV2;
     178             :     int nBudgetCycleBlocks;
     179             :     int nBudgetFeeConfirmations;
     180             :     int nCoinbaseMaturity;
     181             :     int nFutureTimeDriftPoW;
     182             :     int nFutureTimeDriftPoS;
     183             :     CAmount nMaxMoneyOut;
     184             :     CAmount nMNCollateralAmt;
     185             :     int nMNCollateralMinConf;
     186             :     CAmount nMNBlockReward;
     187             :     CAmount nNewMNBlockReward;
     188             :     int64_t nProposalEstablishmentTime;
     189             :     int nStakeMinAge;
     190             :     int nStakeMinDepth;
     191             :     int64_t nTargetTimespan;
     192             :     int64_t nTargetTimespanV2;
     193             :     int64_t nTargetSpacing;
     194             :     int nTimeSlotLength;
     195             :     int nMaxProposalPayments;
     196             : 
     197             :     // spork keys
     198             :     std::string strSporkPubKey;
     199             :     std::string strSporkPubKeyOld;
     200             :     int64_t nTime_EnforceNewSporkKey;
     201             :     int64_t nTime_RejectOldSporkKey;
     202             : 
     203             :     // height-based activations
     204             :     int height_last_invalid_UTXO;
     205             :     int height_last_ZC_AccumCheckpoint;
     206             :     int height_last_ZC_WrappedSerials;
     207             : 
     208             :     // validation by-pass
     209             :     int64_t nPivxBadBlockTime;
     210             :     unsigned int nPivxBadBlockBits;
     211             : 
     212             :     // Map with network updates
     213             :     NetworkUpgrade vUpgrades[MAX_NETWORK_UPGRADES];
     214             : 
     215           0 :     int64_t TargetTimespan(const bool fV2 = true) const { return fV2 ? nTargetTimespanV2 : nTargetTimespan; }
     216           0 :     uint256 ProofOfStakeLimit(const bool fV2) const { return fV2 ? posLimitV2 : posLimitV1; }
     217    13994299 :     bool MoneyRange(const CAmount& nValue) const { return (nValue >= 0 && nValue <= nMaxMoneyOut); }
     218           0 :     bool IsTimeProtocolV2(const int nHeight) const { return NetworkUpgradeActive(nHeight, UPGRADE_V4_0); }
     219        1106 :     int MasternodeCollateralMinConf() const { return nMNCollateralMinConf; }
     220             : 
     221           0 :     int FutureBlockTimeDrift(const int nHeight) const
     222             :     {
     223             :         // PoS (TimeV2): 14 seconds
     224           0 :         if (IsTimeProtocolV2(nHeight)) return nTimeSlotLength - 1;
     225             :         // PoS (TimeV1): 3 minutes - PoW: 2 hours
     226           0 :         return (NetworkUpgradeActive(nHeight, UPGRADE_POS) ? nFutureTimeDriftPoS : nFutureTimeDriftPoW);
     227             :     }
     228             : 
     229           0 :     bool IsValidBlockTimeStamp(const int64_t nTime, const int nHeight) const
     230             :     {
     231             :         // Before time protocol V2, blocks can have arbitrary timestamps
     232           0 :         if (!IsTimeProtocolV2(nHeight)) return true;
     233             :         // Time protocol v2 requires time in slots
     234           0 :         return (nTime % nTimeSlotLength) == 0;
     235             :     }
     236             : 
     237        2537 :     bool HasStakeMinAgeOrDepth(const int contextHeight, const uint32_t contextTime,
     238             :             const int utxoFromBlockHeight, const uint32_t utxoFromBlockTime) const
     239             :     {
     240             :         // before stake modifier V2, we require the utxo to be nStakeMinAge old
     241        2537 :         if (!NetworkUpgradeActive(contextHeight, Consensus::UPGRADE_V3_4))
     242           0 :             return (utxoFromBlockTime + nStakeMinAge <= contextTime);
     243             :         // with stake modifier V2+, we require the utxo to be nStakeMinDepth deep in the chain
     244        2537 :         return (contextHeight - utxoFromBlockHeight >= nStakeMinDepth);
     245             :     }
     246             : 
     247             : 
     248             :     /*
     249             :      * (Legacy) Zerocoin consensus params
     250             :      */
     251             :     std::string ZC_Modulus;  // parsed in Zerocoin_Params (either as hex or dec string)
     252             :     int ZC_MaxPublicSpendsPerTx;
     253             :     int ZC_MaxSpendsPerTx;
     254             :     int ZC_MinMintConfirmations;
     255             :     CAmount ZC_MinMintFee;
     256             :     int ZC_MinStakeDepth;
     257             :     int ZC_TimeStart;
     258             :     int ZC_HeightStart;
     259             : 
     260        6718 :     libzerocoin::ZerocoinParams* Zerocoin_Params(bool useModulusV1) const
     261             :     {
     262        6718 :         static CBigNum bnHexModulus = 0;
     263        6718 :         if (!bnHexModulus) bnHexModulus.SetHex(ZC_Modulus);
     264        6718 :         static libzerocoin::ZerocoinParams ZCParamsHex = libzerocoin::ZerocoinParams(bnHexModulus);
     265        6718 :         static CBigNum bnDecModulus = 0;
     266        6718 :         if (!bnDecModulus) bnDecModulus.SetDec(ZC_Modulus);
     267        6718 :         static libzerocoin::ZerocoinParams ZCParamsDec = libzerocoin::ZerocoinParams(bnDecModulus);
     268       13436 :         return (useModulusV1 ? &ZCParamsHex : &ZCParamsDec);
     269             :     }
     270             : 
     271             :     /**
     272             :      * Returns true if the given network upgrade is active as of the given block
     273             :      * height. Caller must check that the height is >= 0 (and handle unknown
     274             :      * heights).
     275             :      */
     276             :     bool NetworkUpgradeActive(int nHeight, Consensus::UpgradeIndex idx) const;
     277             : 
     278             :     // LLMQ
     279             :     std::map<LLMQType, LLMQParams> llmqs;
     280             :     Optional<LLMQParams> GetLLMQParams(uint8_t llmqtype) const;
     281             :     LLMQType llmqTypeChainLocks;
     282             : };
     283             : } // namespace Consensus
     284             : 
     285             : #endif // PIVX_CONSENSUS_PARAMS_H

Generated by: LCOV version 1.14