diff --git a/src/activemasternode.cpp b/src/activemasternode.cpp index 3484c16eb043..26ed9d6b629a 100644 --- a/src/activemasternode.cpp +++ b/src/activemasternode.cpp @@ -61,8 +61,6 @@ void CActiveMasternodeManager::Init() if (!fMasternodeMode) return; - if (!deterministicMNManager->IsDIP3Enforced()) return; - // Check that our local network configuration is correct if (!fListen) { // listen option is probably overwritten by smth else, no good @@ -131,8 +129,6 @@ void CActiveMasternodeManager::UpdatedBlockTip(const CBlockIndex* pindexNew, con if (!fMasternodeMode) return; - if (!deterministicMNManager->IsDIP3Enforced(pindexNew->nHeight)) return; - if (state == MASTERNODE_READY) { auto mnList = deterministicMNManager->GetListForBlock(pindexNew->GetBlockHash()); if (!mnList.IsMNValid(mnListEntry->proTxHash)) { diff --git a/src/chainparams.cpp b/src/chainparams.cpp index 923e43dd8188..2926ca824fd7 100644 --- a/src/chainparams.cpp +++ b/src/chainparams.cpp @@ -118,7 +118,7 @@ static CBlock FindDevNetGenesisBlock(const Consensus::Params& params, const CBlo static Consensus::LLMQParams llmq5_60 = { .type = Consensus::LLMQ_5_60, .name = "llmq_5_60", - .size = 5, + .size = 3, .minSize = 3, .threshold = 3, @@ -223,7 +223,6 @@ class CMainParams : public CChainParams { consensus.nGovernanceFilterElements = 20000; consensus.nMasternodeMinimumConfirmations = 15; consensus.nMasternodeCollateral = 500000 * COIN; - consensus.nCollateralBugHeight = 331460; consensus.BIP34Height = 951; consensus.BIP34Hash = uint256S("0x000001f35e70f7c5705f64c6c5cc3dea9449e74d5b5c7cf74dad1bcca14a8012"); consensus.BIP65Height = 619382; @@ -398,41 +397,40 @@ class CTestNetParams : public CChainParams { public: CTestNetParams() { strNetworkID = "test"; - consensus.nSubsidyHalvingInterval = NEVER32; // unused + consensus.nSubsidyHalvingInterval = NEVER32; consensus.nMasternodePaymentsStartBlock = 50; consensus.nMasternodePaymentsIncreaseBlock = NEVER32; consensus.nMasternodePaymentsIncreasePeriod = NEVER32; consensus.nInstantSendConfirmationsRequired = 2; consensus.nInstantSendKeepLock = 6; - consensus.nInstantSendSigsRequired = 6; - consensus.nInstantSendSigsTotal = 10; - consensus.nBudgetPaymentsStartBlock = NEVER32; - consensus.nBudgetPaymentsCycleBlocks = NEVER32; - consensus.nBudgetPaymentsWindowBlocks = NEVER32; - consensus.nSuperblockStartBlock = NEVER32; - consensus.nSuperblockStartHash = uint256(); // do not check this on testnet - consensus.nSuperblockCycle = 24; // Superblocks can be issued hourly on testnet + consensus.nInstantSendSigsRequired = 2; + consensus.nInstantSendSigsTotal = 4; + consensus.nBudgetPaymentsStartBlock = 50; + consensus.nBudgetPaymentsCycleBlocks = 50; + consensus.nBudgetPaymentsWindowBlocks = 100; + consensus.nSuperblockStartBlock = 100; + consensus.nSuperblockStartHash = uint256(); + consensus.nSuperblockCycle = 24; consensus.nGovernanceMinQuorum = 1; consensus.nGovernanceFilterElements = 500; consensus.nMasternodeMinimumConfirmations = 15; - consensus.nMasternodeCollateral = 5000 * COIN; - consensus.nCollateralBugHeight = 0; + consensus.nMasternodeCollateral = 1000 * COIN; consensus.BIP34Height = 1; consensus.BIP34Hash = uint256S("0x0000000000000000000000000000000000000000000000000000000000000000"); consensus.BIP65Height = 0; consensus.BIP66Height = 0; consensus.DIP0001Height = 1; - consensus.DIP0003Height = 50; - consensus.DIP0003EnforcementHeight = 250; + consensus.DIP0003Height = 125; + consensus.DIP0003EnforcementHeight = 25000; consensus.DIP0003EnforcementHash = uint256S("0x0000000000000000000000000000000000000000000000000000000000000000"); consensus.powLimit = uint256S("0000fffff0000000000000000000000000000000000000000000000000000000"); consensus.posLimit = uint256S("007ffff000000000000000000000000000000000000000000000000000000000"); - consensus.nLastPoWBlock = 125; - consensus.nPowTargetTimespan = 450; - consensus.nPowTargetSpacing = 150; + consensus.nLastPoWBlock = consensus.DIP0003Height; + consensus.nPowTargetTimespan = 60; + consensus.nPowTargetSpacing = 60; consensus.nPosTargetSpacing = consensus.nPowTargetSpacing; consensus.nPosTargetTimespan = consensus.nPowTargetTimespan; - consensus.nMinimumStakeValue = 10000 * COIN; + consensus.nMinimumStakeValue = 100 * COIN; consensus.nStakeMinAge = 10 * 60; consensus.nStakeMaxAge = 60 * 60 * 24 * 30; consensus.nModifierInterval = 60 * 20; @@ -442,40 +440,41 @@ class CTestNetParams : public CChainParams { consensus.nPowDGWHeight = NEVER32; // unused consensus.nRuleChangeActivationThreshold = 1512; consensus.nMinerConfirmationWindow = 2016; + consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].bit = 28; - consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime = 1544655600; - consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout = NEVER32; + consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nStartTime = 1573325000; + consensus.vDeployments[Consensus::DEPLOYMENT_TESTDUMMY].nTimeout = NEVER64; // Deployment of BIP68, BIP112, and BIP113. consensus.vDeployments[Consensus::DEPLOYMENT_CSV].bit = 0; - consensus.vDeployments[Consensus::DEPLOYMENT_CSV].nStartTime = 1544655600; - consensus.vDeployments[Consensus::DEPLOYMENT_CSV].nTimeout = NEVER32; + consensus.vDeployments[Consensus::DEPLOYMENT_CSV].nStartTime = 1573325000; + consensus.vDeployments[Consensus::DEPLOYMENT_CSV].nTimeout = NEVER64; // Deployment of DIP0001 consensus.vDeployments[Consensus::DEPLOYMENT_DIP0001].bit = 1; - consensus.vDeployments[Consensus::DEPLOYMENT_DIP0001].nStartTime = 1544655600; - consensus.vDeployments[Consensus::DEPLOYMENT_DIP0001].nTimeout = NEVER32; + consensus.vDeployments[Consensus::DEPLOYMENT_DIP0001].nStartTime = 1573325000; + consensus.vDeployments[Consensus::DEPLOYMENT_DIP0001].nTimeout = NEVER64; consensus.vDeployments[Consensus::DEPLOYMENT_DIP0001].nWindowSize = 100; consensus.vDeployments[Consensus::DEPLOYMENT_DIP0001].nThreshold = 50; // Deployment of BIP147 consensus.vDeployments[Consensus::DEPLOYMENT_BIP147].bit = 2; - consensus.vDeployments[Consensus::DEPLOYMENT_BIP147].nStartTime = 1544655600; - consensus.vDeployments[Consensus::DEPLOYMENT_BIP147].nTimeout = NEVER32; + consensus.vDeployments[Consensus::DEPLOYMENT_BIP147].nStartTime = 1573325000; + consensus.vDeployments[Consensus::DEPLOYMENT_BIP147].nTimeout = NEVER64; consensus.vDeployments[Consensus::DEPLOYMENT_BIP147].nWindowSize = 100; consensus.vDeployments[Consensus::DEPLOYMENT_BIP147].nThreshold = 50; // Deployment of DIP0003 consensus.vDeployments[Consensus::DEPLOYMENT_DIP0003].bit = 3; - consensus.vDeployments[Consensus::DEPLOYMENT_DIP0003].nStartTime = 1544655600; - consensus.vDeployments[Consensus::DEPLOYMENT_DIP0003].nTimeout = NEVER32; + consensus.vDeployments[Consensus::DEPLOYMENT_DIP0003].nStartTime = Consensus::BIP9Deployment::ALWAYS_ACTIVE; + consensus.vDeployments[Consensus::DEPLOYMENT_DIP0003].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT; consensus.vDeployments[Consensus::DEPLOYMENT_DIP0003].nWindowSize = 100; - consensus.vDeployments[Consensus::DEPLOYMENT_DIP0003].nThreshold = 50; + consensus.vDeployments[Consensus::DEPLOYMENT_DIP0003].nThreshold = 10; // Deployment of DIP0008 consensus.vDeployments[Consensus::DEPLOYMENT_DIP0008].bit = 4; - consensus.vDeployments[Consensus::DEPLOYMENT_DIP0008].nStartTime = 1544655600; - consensus.vDeployments[Consensus::DEPLOYMENT_DIP0008].nTimeout = NEVER32; + consensus.vDeployments[Consensus::DEPLOYMENT_DIP0008].nStartTime = Consensus::BIP9Deployment::ALWAYS_ACTIVE; + consensus.vDeployments[Consensus::DEPLOYMENT_DIP0008].nTimeout = Consensus::BIP9Deployment::NO_TIMEOUT; consensus.vDeployments[Consensus::DEPLOYMENT_DIP0008].nWindowSize = 100; consensus.vDeployments[Consensus::DEPLOYMENT_DIP0008].nThreshold = 10; @@ -493,16 +492,26 @@ class CTestNetParams : public CChainParams { nDefaultPort = 29999; nPruneAfterHeight = 1000; - genesis = CreateGenesisBlock(1567646780, 24712, 0x1f00ffff, 1, 0 * COIN, true); + uint32_t nTime = 1573325000; + uint32_t nNonce = 0; + + if (nNonce == 0) { + while (UintToArith256(genesis.GetHash()) > + UintToArith256(consensus.powLimit)) + { + nNonce++; + genesis = CreateGenesisBlock(nTime, nNonce, 0x1f00ffff, 1, 0 * COIN, true); + if (nNonce % 128 == 0) printf("\rgenesis %08x", nNonce); + } + } + + genesis = CreateGenesisBlock(nTime, nNonce, 0x1f00ffff, 1, 0 * COIN, true); consensus.hashGenesisBlock = genesis.GetHash(); - assert(consensus.hashGenesisBlock == uint256S("0x0000d3b6747d6f7fe976c218fe7834d2fa79b661a6debe69a0af9b8faea3b0fa")); vFixedSeeds.clear(); vFixedSeeds = std::vector(pnSeed6_test, pnSeed6_test + ARRAYLEN(pnSeed6_test)); vSeeds.clear(); - vSeeds.push_back(CDNSSeedData("pacglobal.io", "seed2.pacglobal.io")); - vSeeds.push_back(CDNSSeedData("pacglobal.io", "seed3.pacglobal.io")); // Testnet PACGlobal addresses start with 'y' base58Prefixes[PUBKEY_ADDRESS] = std::vector(1,140); @@ -519,25 +528,23 @@ class CTestNetParams : public CChainParams { nExtCoinType = 1; // long living quorum params - consensus.llmqs[Consensus::LLMQ_50_60] = llmq50_60; - consensus.llmqs[Consensus::LLMQ_400_60] = llmq400_60; - consensus.llmqs[Consensus::LLMQ_400_85] = llmq400_85; - consensus.llmqChainLocks = Consensus::LLMQ_50_60; - consensus.llmqForInstaPAC = Consensus::LLMQ_50_60; + consensus.llmqs[Consensus::LLMQ_5_60] = llmq5_60; + consensus.llmqChainLocks = Consensus::LLMQ_5_60; + consensus.llmqForInstaPAC = Consensus::LLMQ_5_60; fMiningRequiresPeers = true; fDefaultConsistencyChecks = false; - fRequireStandard = false; + fRequireStandard = true; fRequireRoutableExternalIP = false; fMineBlocksOnDemand = false; - fAllowMultipleAddressesFromGroup = false; + fAllowMultipleAddressesFromGroup = true; fAllowMultiplePorts = true; nPoolMinParticipants = 3; nPoolMaxParticipants = 5; nFulfilledRequestExpireTime = 5*60; // fulfilled requests expire in 5 minutes - vSporkAddresses = {"yarEgAKyKCAanupC45vXhdWe6DAQf7RKPh"}; + vSporkAddresses = {"yTpFjxs3Rtwe7MXfC1i5XACz2K5UYi2GpL"}; nMinSporkKeys = 1; fBIP9CheckMasternodesUpgraded = true; @@ -582,7 +589,6 @@ class CDevNetParams : public CChainParams { consensus.nGovernanceFilterElements = 500; consensus.nMasternodeMinimumConfirmations = 1; consensus.nMasternodeCollateral = 500000 * COIN; - consensus.nCollateralBugHeight = 0; consensus.BIP34Height = 1; // BIP34 activated immediately on devnet consensus.BIP65Height = 1; // BIP65 activated immediately on devnet consensus.BIP66Height = 1; // BIP66 activated immediately on devnet diff --git a/src/chainparamsseeds.h b/src/chainparamsseeds.h index 286ee99c4404..f7d9e546406e 100644 --- a/src/chainparamsseeds.h +++ b/src/chainparamsseeds.h @@ -8,17 +8,7 @@ * IPv4 as well as onion addresses are wrapped inside a IPv6 address accordingly. */ static SeedSpec6 pnSeed6_main[] = { - {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x74,0xcb,0x9a,0x6e}, 7112}, - {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x74,0xcb,0x9b,0x1a}, 7112}, - {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x74,0xcb,0x37,0x86}, 7112}, - {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x74,0xcb,0xdd,0xf9}, 7112}, - {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x5f,0xd8,0xa3,0x29}, 7112}, - {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x5f,0xd9,0x0b,0x8d}, 7112}, - {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x5f,0xd9,0x0b,0x8c}, 7112}, - {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x5f,0xd8,0x98,0x22}, 7112} }; static SeedSpec6 pnSeed6_test[] = { - {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0x9d,0xe6,0xf4,0xe9}, 29999}, - {{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xa5,0x16,0x64,0x7f}, 29999} }; #endif // PAC_CHAINPARAMSSEEDS_H diff --git a/src/consensus/params.h b/src/consensus/params.h index c23fea1ec44b..3e116bdbf70a 100644 --- a/src/consensus/params.h +++ b/src/consensus/params.h @@ -39,6 +39,13 @@ struct BIP9Deployment { int64_t nWindowSize; /** A number of blocks, in the range of 1..nWindowSize, which must signal for a fork in order to lock it in. */ int64_t nThreshold; + /** Constant for nTimeout very far in the future. */ + static constexpr int64_t NO_TIMEOUT = std::numeric_limits::max(); + /** Special value for nStartTime indicating that the deployment is always active. + * This is useful for testing, as it means tests don't need to deal with the activation + * process (which takes at least 3 BIP9 intervals). Only tests that specifically test the + * behaviour during activation cannot use this. */ + static constexpr int64_t ALWAYS_ACTIVE = -1; }; enum LLMQType : uint8_t @@ -138,7 +145,6 @@ struct Params { int nGovernanceFilterElements; int nMasternodeMinimumConfirmations; CAmount nMasternodeCollateral; - int nCollateralBugHeight; /** Block height and hash at which BIP34 becomes active */ int BIP34Height; uint256 BIP34Hash; diff --git a/src/evo/cbtx.cpp b/src/evo/cbtx.cpp index 85ed1c297e98..0c829253668b 100644 --- a/src/evo/cbtx.cpp +++ b/src/evo/cbtx.cpp @@ -38,12 +38,12 @@ bool CheckCbTx(const CTransaction& tx, const CBlockIndex* pindexPrev, CValidatio return state.DoS(100, false, REJECT_INVALID, "bad-cbtx-height"); } - if (pindexPrev) { - bool fDIP0008Active = VersionBitsState(pindexPrev, Params().GetConsensus(), Consensus::DEPLOYMENT_DIP0008, versionbitscache) == THRESHOLD_ACTIVE; - if (fDIP0008Active && cbTx.nVersion < 2) { - return state.DoS(100, false, REJECT_INVALID, "bad-cbtx-version"); - } - } +// if (pindexPrev) { +// bool fDIP0008Active = VersionBitsState(pindexPrev, Params().GetConsensus(), Consensus::DEPLOYMENT_DIP0008, versionbitscache) == THRESHOLD_ACTIVE; +// if (fDIP0008Active && cbTx.nVersion < 2) { +// return state.DoS(100, false, REJECT_INVALID, "bad-cbtx-version"); +// } +// } return true; } diff --git a/src/evo/providertx.cpp b/src/evo/providertx.cpp index ada2b45eb941..6b239d0d1d7c 100644 --- a/src/evo/providertx.cpp +++ b/src/evo/providertx.cpp @@ -185,12 +185,6 @@ bool CheckProRegTx(const CTransaction& tx, const CBlockIndex* pindexPrev, CValid if (mnList.HasUniqueProperty(ptx.keyIDOwner) || mnList.HasUniqueProperty(ptx.pubKeyOperator)) { return state.DoS(10, false, REJECT_DUPLICATE, "bad-protx-dup-key"); } - - if (!deterministicMNManager->IsDIP3Enforced(pindexPrev->nHeight)) { - if (ptx.keyIDOwner != ptx.keyIDVoting) { - return state.DoS(10, false, REJECT_INVALID, "bad-protx-key-not-same"); - } - } } if (!CheckInputsHash(tx, ptx, state)) { @@ -330,15 +324,10 @@ bool CheckProUpRegTx(const CTransaction& tx, const CBlockIndex* pindexPrev, CVal } } - if (!deterministicMNManager->IsDIP3Enforced(pindexPrev->nHeight)) { - if (dmn->pdmnState->keyIDOwner != ptx.keyIDVoting) { - return state.DoS(10, false, REJECT_INVALID, "bad-protx-key-not-same"); - } - } - if (!CheckInputsHash(tx, ptx, state)) { return false; } + if (!CheckHashSig(ptx, dmn->pdmnState->keyIDOwner, state)) { return false; } diff --git a/src/governance.cpp b/src/governance.cpp index 18a2b11812a1..a6c4d6c18226 100644 --- a/src/governance.cpp +++ b/src/governance.cpp @@ -1268,9 +1268,7 @@ void CGovernanceManager::UpdatedBlockTip(const CBlockIndex* pindex, CConnman& co nCachedBlockHeight = pindex->nHeight; LogPrint("gobject", "CGovernanceManager::UpdatedBlockTip -- nCachedBlockHeight: %d\n", nCachedBlockHeight); - if (deterministicMNManager->IsDIP3Enforced(pindex->nHeight)) { - RemoveInvalidVotes(); - } + RemoveInvalidVotes(); CheckPostponedObjects(connman); diff --git a/src/llmq/quorums_chainlocks.cpp b/src/llmq/quorums_chainlocks.cpp index cdb5d99ac14c..f28429ca9019 100644 --- a/src/llmq/quorums_chainlocks.cpp +++ b/src/llmq/quorums_chainlocks.cpp @@ -317,11 +317,13 @@ void CChainLocksHandler::TrySignChainTip() } } +#if 0 if (txAge < WAIT_FOR_ISLOCK_TIMEOUT && !quorumInstantSendManager->IsLocked(txid)) { LogPrint("chainlocks", "CChainLocksHandler::%s -- not signing block %s due to TX %s not being ixlocked and not old enough. age=%d\n", __func__, pindexWalk->GetBlockHash().ToString(), txid.ToString(), txAge); return; } +#endif } pindexWalk = pindexWalk->pprev; diff --git a/src/llmq/quorums_dkgsessionhandler.cpp b/src/llmq/quorums_dkgsessionhandler.cpp index 9a032b016994..2b9b91a368d8 100644 --- a/src/llmq/quorums_dkgsessionhandler.cpp +++ b/src/llmq/quorums_dkgsessionhandler.cpp @@ -147,10 +147,6 @@ bool CDKGSessionHandler::InitNewQuorum(int newQuorumHeight, const uint256& newQu curSession = std::make_shared(params, blsWorker, dkgManager); - if (!deterministicMNManager->IsDIP3Enforced(newQuorumHeight)) { - return false; - } - auto mns = CLLMQUtils::GetAllQuorumMembers(params.type, newQuorumHash); if (!curSession->Init(newQuorumHeight, newQuorumHash, mns, activeMasternodeInfo.proTxHash)) { diff --git a/src/llmq/quorums_dkgsessionmgr.cpp b/src/llmq/quorums_dkgsessionmgr.cpp index c68d95d00ad8..d819f3f232f2 100644 --- a/src/llmq/quorums_dkgsessionmgr.cpp +++ b/src/llmq/quorums_dkgsessionmgr.cpp @@ -56,8 +56,7 @@ void CDKGSessionManager::UpdatedBlockTip(const CBlockIndex* pindexNew, bool fIni if (fInitialDownload) return; - if (!deterministicMNManager->IsDIP3Enforced(pindexNew->nHeight)) - return; + if (!sporkManager.IsSporkActive(SPORK_17_QUORUM_DKG_ENABLED)) return; diff --git a/src/masternode-payments.cpp b/src/masternode-payments.cpp index c7e77617a51f..1357f38133ca 100644 --- a/src/masternode-payments.cpp +++ b/src/masternode-payments.cpp @@ -21,49 +21,6 @@ CMasternodePayments mnpayments; -bool IsOldBudgetBlockValueValid(const CBlock& block, int nBlockHeight, CAmount blockReward, std::string& strErrorRet) { - const Consensus::Params& consensusParams = Params().GetConsensus(); - bool isBlockRewardValueMet = (block.vtx[0]->GetValueOut() <= blockReward); - - if (nBlockHeight < consensusParams.nBudgetPaymentsStartBlock) { - strErrorRet = strprintf("Incorrect block %d, old budgets are not activated yet", nBlockHeight); - return false; - } - - if (nBlockHeight >= consensusParams.nSuperblockStartBlock) { - strErrorRet = strprintf("Incorrect block %d, old budgets are no longer active", nBlockHeight); - return false; - } - - // we are still using budgets, but we have no data about them anymore, - // all we know is predefined budget cycle and window - - int nOffset = nBlockHeight % consensusParams.nBudgetPaymentsCycleBlocks; - if(nBlockHeight >= consensusParams.nBudgetPaymentsStartBlock && - nOffset < consensusParams.nBudgetPaymentsWindowBlocks) { - // NOTE: old budget system is disabled since 12.1 - if(masternodeSync.IsSynced()) { - // no old budget blocks should be accepted here on mainnet, - // testnet/devnet/regtest should produce regular blocks only - LogPrint("gobject", "%s -- WARNING: Client synced but old budget system is disabled, checking block value against block reward\n", __func__); - if(!isBlockRewardValueMet) { - strErrorRet = strprintf("coinbase pays too much at height %d (actual=%d vs limit=%d), exceeded block reward, old budgets are disabled", - nBlockHeight, block.vtx[0]->GetValueOut(), blockReward); - } - return isBlockRewardValueMet; - } - // when not synced, rely on online nodes (all networks) - LogPrint("gobject", "%s -- WARNING: Skipping old budget block value checks, accepting block\n", __func__); - return true; - } - // LogPrint("gobject", "%s -- Block is not in budget cycle window, checking block value against block reward\n", __func__); - if(!isBlockRewardValueMet) { - strErrorRet = strprintf("coinbase pays too much at height %d (actual=%d vs limit=%d), exceeded block reward, block is not in old budget cycle window", - nBlockHeight, block.vtx[0]->GetValueOut(), blockReward); - } - return isBlockRewardValueMet; -} - /** * IsBlockValueValid * @@ -77,38 +34,30 @@ bool IsOldBudgetBlockValueValid(const CBlock& block, int nBlockHeight, CAmount b bool IsBlockValueValid(const CBlock& block, int nBlockHeight, CAmount blockReward, std::string& strErrorRet) { - const Consensus::Params& consensusParams = Params().GetConsensus(); - bool isBlockRewardValueMet = (block.vtx[0]->GetValueOut() <= blockReward); - - strErrorRet = ""; + int n = block.IsProofOfStake() ? 1 : 0; + CAmount nValueIn = 0; + if (block.IsProofOfStake()) { + CCoinsViewCache view(pcoinsTip); + nValueIn += view.GetValueIn(*block.vtx[1]); + } - bool isProofOfStake = !block.IsProofOfWork(); - const auto& coinbaseTransaction = block.vtx[isProofOfStake]; + CAmount blockValue = block.vtx[n]->GetValueOut() - nValueIn; + bool isBlockRewardValueMet = (blockValue <= blockReward); - if (nBlockHeight < consensusParams.nBudgetPaymentsStartBlock) { - // old budget system is not activated yet, just make sure we do not exceed the regular block reward - if(!isBlockRewardValueMet) { - strErrorRet = strprintf("coinbase pays too much at height %d (actual=%d vs limit=%d), exceeded block reward, old budgets are not activated yet", - nBlockHeight, block.vtx[0]->GetValueOut(), blockReward); - } - return isBlockRewardValueMet; - } else if (nBlockHeight < consensusParams.nSuperblockStartBlock) { - // superblocks are not enabled yet, check if we can pass old budget rules - return IsOldBudgetBlockValueValid(block, nBlockHeight, blockReward, strErrorRet); - } + strErrorRet = ""; - if(fDebug) LogPrintf("block.vtx[0]->GetValueOut() %lld <= blockReward %lld\n", block.vtx[0]->GetValueOut(), blockReward); + LogPrintf(" - blockValue %lld <= blockReward %lld\n", blockValue, blockReward); - CAmount nSuperblockMaxValue = blockReward + CSuperblock::GetPaymentsLimit(nBlockHeight); - bool isSuperblockMaxValueMet = (block.vtx[0]->GetValueOut() <= nSuperblockMaxValue); + CAmount nSuperblockMaxValue = blockReward + CSuperblock::GetPaymentsLimit(nBlockHeight); + bool isSuperblockMaxValueMet = (blockValue <= nSuperblockMaxValue); - LogPrint("gobject", "block.vtx[0]->GetValueOut() %lld <= nSuperblockMaxValue %lld\n", block.vtx[0]->GetValueOut(), nSuperblockMaxValue); + LogPrintf(" - blockValue %lld <= nSuperblockMaxValue %lld\n", blockValue, nSuperblockMaxValue); if (!CSuperblock::IsValidBlockHeight(nBlockHeight)) { // can't possibly be a superblock, so lets just check for block reward limits if (!isBlockRewardValueMet) { strErrorRet = strprintf("coinbase pays too much at height %d (actual=%d vs limit=%d), exceeded block reward, only regular blocks are allowed at this height", - nBlockHeight, block.vtx[0]->GetValueOut(), blockReward); + nBlockHeight, blockValue, blockReward); } return isBlockRewardValueMet; } @@ -116,26 +65,25 @@ bool IsBlockValueValid(const CBlock& block, int nBlockHeight, CAmount blockRewar // bail out in case superblock limits were exceeded if (!isSuperblockMaxValueMet) { strErrorRet = strprintf("coinbase pays too much at height %d (actual=%d vs limit=%d), exceeded superblock max value", - nBlockHeight, block.vtx[0]->GetValueOut(), nSuperblockMaxValue); + nBlockHeight, blockValue, nSuperblockMaxValue); return false; } - if(!masternodeSync.IsSynced() || fLiteMode) { - if(fDebug) LogPrintf("%s -- WARNING: Not enough data, checked superblock max bounds only\n", __func__); + if (!masternodeSync.IsSynced() || fLiteMode) { + LogPrintf(" - %s -- WARNING: Not enough data, checked superblock max bounds only\n", __func__); // not enough data for full checks but at least we know that the superblock limits were honored. // We rely on the network to have followed the correct chain in this case return true; } // we are synced and possibly on a superblock now - if (!sporkManager.IsSporkActive(SPORK_9_SUPERBLOCKS_ENABLED)) { // should NOT allow superblocks at all, when superblocks are disabled // revert to block reward limits in this case - LogPrint("gobject", "%s -- Superblocks are disabled, no superblocks allowed\n", __func__); - if(!isBlockRewardValueMet) { + LogPrintf(" - %s -- Superblocks are disabled, no superblocks allowed\n", __func__); + if (!isBlockRewardValueMet) { strErrorRet = strprintf("coinbase pays too much at height %d (actual=%d vs limit=%d), exceeded block reward, superblocks are disabled", - nBlockHeight, block.vtx[0]->GetValueOut(), blockReward); + nBlockHeight, blockValue, blockReward); } return isBlockRewardValueMet; } @@ -143,17 +91,17 @@ bool IsBlockValueValid(const CBlock& block, int nBlockHeight, CAmount blockRewar if (!CSuperblockManager::IsSuperblockTriggered(nBlockHeight)) { // we are on a valid superblock height but a superblock was not triggered // revert to block reward limits in this case - if(!isBlockRewardValueMet) { + if (!isBlockRewardValueMet) { strErrorRet = strprintf("coinbase pays too much at height %d (actual=%d vs limit=%d), exceeded block reward, no triggered superblock detected", - nBlockHeight, block.vtx[0]->GetValueOut(), blockReward); + nBlockHeight, blockValue, blockReward); } return isBlockRewardValueMet; } // this actually also checks for correct payees and not only amount - if (!CSuperblockManager::IsValid(*block.vtx[0], nBlockHeight, blockReward)) { + if (!CSuperblockManager::IsValid(*block.vtx[n], nBlockHeight, blockReward)) { // triggered but invalid? that's weird - LogPrintf("%s -- ERROR: Invalid superblock detected at height %d: %s", __func__, nBlockHeight, block.vtx[0]->ToString()); + LogPrintf(" - %s -- ERROR: Invalid superblock detected at height %d: %s", __func__, nBlockHeight, block.vtx[n]->ToString()); // should NOT allow invalid superblocks, when superblocks are enabled strErrorRet = strprintf("invalid superblock detected at height %d", nBlockHeight); return false; @@ -372,11 +320,6 @@ bool CMasternodePayments::IsScheduled(const CDeterministicMNCPtr& dmnIn, int nNo bool CMasternodePayments::IsTransactionValid(const CTransaction& txNew, int nBlockHeight, CAmount blockReward) const { - if (!deterministicMNManager->IsDIP3Enforced(nBlockHeight)) { - // can't verify historical blocks here - return true; - } - std::vector voutMasternodePayments; if (!GetBlockTxOuts(nBlockHeight, blockReward, voutMasternodePayments)) { LogPrintf("CMasternodePayments::%s -- ERROR failed to get payees for block at height %s\n", __func__, nBlockHeight); @@ -395,6 +338,7 @@ bool CMasternodePayments::IsTransactionValid(const CTransaction& txNew, int nBlo CTxDestination dest; if (!ExtractDestination(txout.scriptPubKey, dest)) assert(false); + LogPrintf("found -> %s\n", txNew.ToString().c_str()); LogPrintf("CMasternodePayments::%s -- ERROR failed to find expected payee %s in block at height %s\n", __func__, CBitcoinAddress(dest).ToString(), nBlockHeight); return false; } diff --git a/src/masternode-sync.cpp b/src/masternode-sync.cpp index 5f5744a3aa7d..67d571609bc0 100644 --- a/src/masternode-sync.cpp +++ b/src/masternode-sync.cpp @@ -184,7 +184,9 @@ void CMasternodeSync::ProcessTick(CConnman& connman) // NORMAL NETWORK MODE - TESTNET/MAINNET { - if(netfulfilledman.HasFulfilledRequest(pnode->addr, "full-sync")) { + if(netfulfilledman.HasFulfilledRequest(pnode->addr, "full-sync") && + Params().NetworkIDString() == CBaseChainParams::MAIN) + { // We already fully synced from this node recently, // disconnect to free this connection slot for another peer. pnode->fDisconnect = true; diff --git a/src/miner.cpp b/src/miner.cpp index 27ba61c20782..55c6d1c1b2bf 100644 --- a/src/miner.cpp +++ b/src/miner.cpp @@ -171,27 +171,26 @@ std::unique_ptr BlockAssembler::CreateNewBlock(const CScript& sc // Create coinbase transaction. CMutableTransaction coinbaseTx; + CMutableTransaction coinstakeTx; coinbaseTx.vin.resize(1); coinbaseTx.vin[0].prevout.SetNull(); coinbaseTx.vout.resize(1); coinbaseTx.vout[0].scriptPubKey = scriptPubKeyIn; CAmount blockReward = GetBlockSubsidy(pindexPrev->nHeight, Params().GetConsensus()); std::vector vwtxPrev; + bool fStakeFound = false; if(fProofOfStake) { assert(pwalletMain); boost::this_thread::interruption_point(); pblock->nBits = GetNextWorkRequired(pindexPrev, chainparams.GetConsensus()); - CMutableTransaction coinstakeTx; int64_t nSearchTime = pblock->nTime; // search to current time - bool fStakeFound = false; if (nSearchTime >= nLastCoinStakeSearchTime) { unsigned int nTxNewTime = 0; if (pwalletMain->CreateCoinStake(*pwalletMain, pblock->nBits, blockReward, coinstakeTx, nTxNewTime, vwtxPrev)) { pblock->nTime = nTxNewTime; coinbaseTx.vout[0].SetEmpty(); FillBlockPayments(coinstakeTx, nHeight, blockReward, pblocktemplate->voutMasternodePayments, pblocktemplate->voutSuperblockPayments); - pblock->vtx.emplace_back(MakeTransactionRef(coinstakeTx)); fStakeFound = true; } nLastCoinStakeSearchInterval = nSearchTime - nLastCoinStakeSearchTime; @@ -254,11 +253,14 @@ std::unique_ptr BlockAssembler::CreateNewBlock(const CScript& sc throw std::runtime_error(strprintf("%s: CalcCbTxMerkleRootQuorums failed: %s", __func__, FormatStateMessage(state))); } } - SetTxPayload(coinbaseTx, cbTx); } pblock->vtx[0] = MakeTransactionRef(std::move(coinbaseTx)); + if (fStakeFound) { + //pblock->vtx.emplace_back(MakeTransactionRef(coinstakeTx)); + pblock->vtx[1] = MakeTransactionRef(std::move(coinstakeTx)); + } pblocktemplate->vTxFees[0] = -nFees; // Fill in header diff --git a/src/policy/policy.cpp b/src/policy/policy.cpp index c7a2084e2fb5..ee6a7218ddf8 100644 --- a/src/policy/policy.cpp +++ b/src/policy/policy.cpp @@ -104,8 +104,7 @@ bool IsStandardTx(const CTransaction& tx, std::string& reason) reason = "bare-multisig"; return false; } else if (txout.IsDust(MinRelayFee())) { - reason = "dust"; - return false; + return true; } } diff --git a/src/wallet/wallet.cpp b/src/wallet/wallet.cpp index 02342cc96de4..bd04ed7d613d 100644 --- a/src/wallet/wallet.cpp +++ b/src/wallet/wallet.cpp @@ -2807,6 +2807,10 @@ bool CWallet::SelectCoins(const std::vector& vAvailableCoins, const CAm if(!out.fSpendable) continue; + // never select from collateral type amounts + if (out.tx->tx->vout[out.i].nValue == Params().GetConsensus().nMasternodeCollateral) + continue; + if(nCoinType == ONLY_DENOMINATED) { COutPoint outpoint = COutPoint(out.tx->GetHash(),out.i); int nRounds = GetCappedOutpointPrivateSendRounds(outpoint); @@ -3345,11 +3349,6 @@ bool CWallet::CreateTransaction(const std::vector& vecSend, CWalletT return false; } - if (recipient.nAmount < COIN && nExtraPayloadSize == 0) - { - strFailReason = _("Output amounts must be equal to or greater than 1 PAC"); - return false; - } nValue += recipient.nAmount; if (recipient.fSubtractFeeFromAmount) @@ -3436,20 +3435,6 @@ bool CWallet::CreateTransaction(const std::vector& vecSend, CWalletT txout.nValue -= nFeeRet % nSubtractFeeFromAmount; } } - - if (txout.IsDust(MinRelayFee())) - { - if (recipient.fSubtractFeeFromAmount && nFeeRet > 0) - { - if (txout.nValue < 0) - strFailReason = _("The transaction amount is too small to pay the fee"); - else - strFailReason = _("The transaction amount is too small to send after the fee has been deducted"); - } - else - strFailReason = _("Transaction amount too small"); - return false; - } txNew.vout.push_back(txout); }