pivx/doxygen/budget__tests_8cpp_source.html

 // Copyright (c) 2018-2022 The PIVX Core developers

 // Distributed under the MIT/X11 software license, see the accompanying

 // file COPYING or http://www.opensource.org/licenses/mit-license.php.


 #include "test_pivx.h"


 #include "bls/bls_wrapper.h"

 #include "budget/budgetmanager.h"

 #include "masternode-payments.h"

 #include "spork.h"

 #include "test/util/blocksutil.h"

 #include "tiertwo/tiertwo_sync_state.h"

 #include "tinyformat.h"

 #include "utilmoneystr.h"

 #include "validation.h"


 #include <boost/test/unit_test.hpp>


 BOOST_AUTO_TEST_SUITE(budget_tests)


 void CheckBudgetValue(int nHeight, std::string strNetwork, CAmount nExpectedValue)

 {

     CBudgetManager budget;

     CAmount nBudget = g_budgetman.GetTotalBudget(nHeight);

     std::string strError = strprintf("Budget is not as expected for %s. Result: %s, Expected: %s", strNetwork, FormatMoney(nBudget), FormatMoney(nExpectedValue));

     BOOST_CHECK_MESSAGE(nBudget == nExpectedValue, strError);

 }


 void enableMnSyncAndSuperblocksPayment()

 {

     // force mnsync complete

     g_tiertwo_sync_state.SetCurrentSyncPhase(MASTERNODE_SYNC_FINISHED);


     // enable SPORK_13

     int64_t nTime = GetTime() - 10;

     CSporkMessage spork(SPORK_13_ENABLE_SUPERBLOCKS, nTime + 1, nTime);

     sporkManager.AddOrUpdateSporkMessage(spork);

     BOOST_CHECK(sporkManager.IsSporkActive(SPORK_13_ENABLE_SUPERBLOCKS));


     spork = CSporkMessage(SPORK_9_MASTERNODE_BUDGET_ENFORCEMENT, nTime + 1, nTime);

     sporkManager.AddOrUpdateSporkMessage(spork);

     BOOST_CHECK(sporkManager.IsSporkActive(SPORK_9_MASTERNODE_BUDGET_ENFORCEMENT));

 }


 BOOST_AUTO_TEST_CASE(masternode_value)

 {

     SelectParams(CBaseChainParams::REGTEST);

     int nHeightTest = Params().GetConsensus().vUpgrades[Consensus::UPGRADE_V5_5].nActivationHeight + 1;

     BOOST_CHECK_EQUAL(GetMasternodePayment(nHeightTest - 1), 3 * COIN);

     BOOST_CHECK_EQUAL(GetMasternodePayment(nHeightTest), 6 * COIN);

 }


 BOOST_AUTO_TEST_CASE(budget_value)

 {

     SelectParams(CBaseChainParams::TESTNET);

     int nHeightTest = Params().GetConsensus().vUpgrades[Consensus::UPGRADE_ZC_V2].nActivationHeight + 1;

     CheckBudgetValue(nHeightTest-1, "testnet", 7200*COIN);

     CheckBudgetValue(nHeightTest, "testnet", 144*COIN);


     SelectParams(CBaseChainParams::MAIN);

     nHeightTest = Params().GetConsensus().vUpgrades[Consensus::UPGRADE_ZC_V2].nActivationHeight + 1;

     CheckBudgetValue(nHeightTest, "mainnet", 43200*COIN);


     SelectParams(CBaseChainParams::TESTNET);

     nHeightTest = Params().GetConsensus().vUpgrades[Consensus::UPGRADE_V5_5].nActivationHeight + 1;

     CheckBudgetValue(nHeightTest-1, "testnet", 144*COIN);

     CheckBudgetValue(nHeightTest, "testnet", 1440*COIN);


     SelectParams(CBaseChainParams::MAIN);

     nHeightTest = Params().GetConsensus().vUpgrades[Consensus::UPGRADE_V5_5].nActivationHeight + 1;

     CheckBudgetValue(nHeightTest-1, "mainnet", 43200*COIN);

     CheckBudgetValue(nHeightTest, "mainnet", 432000*COIN);


 }


 BOOST_FIXTURE_TEST_CASE(block_value, TestnetSetup)

 {

     enableMnSyncAndSuperblocksPayment();

     int nHeight = 100; std::string strError;

     const CAmount nBlockReward = GetBlockValue(nHeight);

     CAmount nExpectedRet = nBlockReward;

     CAmount nBudgetAmtRet = 0;


     // regular block

     BOOST_CHECK(IsBlockValueValid(nHeight, nExpectedRet, 0, nBudgetAmtRet));

     BOOST_CHECK(IsBlockValueValid(nHeight, nExpectedRet, nBlockReward-1, nBudgetAmtRet));

     BOOST_CHECK_EQUAL(nExpectedRet, nBlockReward);

     BOOST_CHECK_EQUAL(nBudgetAmtRet, 0);

     BOOST_CHECK(IsBlockValueValid(nHeight, nExpectedRet, nBlockReward, nBudgetAmtRet));

     BOOST_CHECK_EQUAL(nExpectedRet, nBlockReward);

     BOOST_CHECK_EQUAL(nBudgetAmtRet, 0);

     BOOST_CHECK(!IsBlockValueValid(nHeight, nExpectedRet, nBlockReward+1, nBudgetAmtRet));

     BOOST_CHECK_EQUAL(nExpectedRet, nBlockReward);

     BOOST_CHECK_EQUAL(nBudgetAmtRet, 0);


     // superblock - create the finalized budget with a proposal, and vote on it

     nHeight = 144;

     const CTxIn mnVin(GetRandHash(), 0);

     const CScript payee = GetScriptForDestination(CKeyID(uint160(ParseHex("816115944e077fe7c803cfa57f29b36bf87c1d35"))));

     const CAmount propAmt = 100 * COIN;

     const uint256& propHash = GetRandHash(), finTxId = GetRandHash();

     const CTxBudgetPayment txBudgetPayment(propHash, payee, propAmt);

     CFinalizedBudget fin("main (test)", 144, {txBudgetPayment}, finTxId);

     const CFinalizedBudgetVote fvote(mnVin, fin.GetHash());

     BOOST_CHECK(fin.AddOrUpdateVote(fvote, strError));

     g_budgetman.ForceAddFinalizedBudget(fin.GetHash(), fin.GetFeeTXHash(), fin);


     // check superblock's block-value

     nExpectedRet = nBlockReward;

     nBudgetAmtRet = 0;

     BOOST_CHECK(IsBlockValueValid(nHeight, nExpectedRet, nBlockReward, nBudgetAmtRet));

     BOOST_CHECK_EQUAL(nExpectedRet, nBlockReward + propAmt);

     BOOST_CHECK_EQUAL(nBudgetAmtRet, propAmt);

     nExpectedRet = nBlockReward;

     nBudgetAmtRet = 0;

     BOOST_CHECK(IsBlockValueValid(nHeight, nExpectedRet, nBlockReward+propAmt-1, nBudgetAmtRet));

     BOOST_CHECK_EQUAL(nExpectedRet, nBlockReward + propAmt);

     BOOST_CHECK_EQUAL(nBudgetAmtRet, propAmt);

     nExpectedRet = nBlockReward;

     nBudgetAmtRet = 0;

     BOOST_CHECK(IsBlockValueValid(nHeight, nExpectedRet, nBlockReward+propAmt, nBudgetAmtRet));

     BOOST_CHECK_EQUAL(nExpectedRet, nBlockReward + propAmt);

     BOOST_CHECK_EQUAL(nBudgetAmtRet, propAmt);

     nExpectedRet = nBlockReward;

     nBudgetAmtRet = 0;

     BOOST_CHECK(!IsBlockValueValid(nHeight, nExpectedRet, nBlockReward+propAmt+1, nBudgetAmtRet));

     BOOST_CHECK_EQUAL(nExpectedRet, nBlockReward + propAmt);

     BOOST_CHECK_EQUAL(nBudgetAmtRet, propAmt);


     // disable SPORK_13

     const CSporkMessage& spork2 = CSporkMessage(SPORK_13_ENABLE_SUPERBLOCKS, 4070908800ULL, GetTime());

     sporkManager.AddOrUpdateSporkMessage(spork2);

     BOOST_CHECK(!sporkManager.IsSporkActive(SPORK_13_ENABLE_SUPERBLOCKS));


     // check with spork disabled

     nExpectedRet = nBlockReward;

     nBudgetAmtRet = 0;

     BOOST_CHECK(IsBlockValueValid(nHeight, nExpectedRet, nBlockReward, nBudgetAmtRet));

     BOOST_CHECK_EQUAL(nExpectedRet, nBlockReward);

     BOOST_CHECK_EQUAL(nBudgetAmtRet, 0);

     BOOST_CHECK(!IsBlockValueValid(nHeight, nExpectedRet, nBlockReward+propAmt-1, nBudgetAmtRet));

     BOOST_CHECK_EQUAL(nExpectedRet, nBlockReward);

     BOOST_CHECK_EQUAL(nBudgetAmtRet, 0);

     BOOST_CHECK(!IsBlockValueValid(nHeight, nExpectedRet, nBlockReward+propAmt, nBudgetAmtRet));

     BOOST_CHECK_EQUAL(nExpectedRet, nBlockReward);

     BOOST_CHECK_EQUAL(nBudgetAmtRet, 0);

     BOOST_CHECK(!IsBlockValueValid(nHeight, nExpectedRet, nBlockReward+propAmt+1, nBudgetAmtRet));

     BOOST_CHECK_EQUAL(nExpectedRet, nBlockReward);

     BOOST_CHECK_EQUAL(nBudgetAmtRet, 0);

 }


 BOOST_FIXTURE_TEST_CASE(block_value_undermint, RegTestingSetup)

 {

     int nHeight = 100;

     CAmount nExpectedRet = GetBlockValue(nHeight);

     CAmount nBudgetAmtRet = 0;

     // under-minting blocks are invalid after v5.3

     BOOST_CHECK(IsBlockValueValid(nHeight, nExpectedRet, -1, nBudgetAmtRet));

     UpdateNetworkUpgradeParameters(Consensus::UPGRADE_V5_3, Consensus::NetworkUpgrade::ALWAYS_ACTIVE);

     BOOST_CHECK(!IsBlockValueValid(nHeight, nExpectedRet, -1, nBudgetAmtRet));

 }


 void forceAddFakeProposals(const CTxOut& payee1, const CTxOut& payee2)

 {

     const CTxIn mnVin(GetRandHash(), 0);

     const uint256& propHash = GetRandHash(), finTxId = GetRandHash();

     const CTxBudgetPayment txBudgetPayment(propHash, payee1.scriptPubKey, payee1.nValue);


     const CTxIn mnVin2(GetRandHash(), 0);

     const uint256& propHash2 = GetRandHash(), finTxId2 = GetRandHash();

     const CTxBudgetPayment txBudgetPayment2(propHash2, payee2.scriptPubKey, payee2.nValue);


     // Create first finalization

     CFinalizedBudget fin("main (test)", 144, {txBudgetPayment, txBudgetPayment2}, finTxId);

     const CFinalizedBudgetVote fvote(mnVin, fin.GetHash());

     const CFinalizedBudgetVote fvote1_a({GetRandHash(), 0}, fin.GetHash());

     const CFinalizedBudgetVote fvote1_b({GetRandHash(), 0}, fin.GetHash());

     std::string strError;

     BOOST_CHECK(fin.AddOrUpdateVote(fvote, strError));

     BOOST_CHECK(fin.AddOrUpdateVote(fvote1_a, strError));

     BOOST_CHECK(fin.AddOrUpdateVote(fvote1_b, strError));

     g_budgetman.ForceAddFinalizedBudget(fin.GetHash(), fin.GetFeeTXHash(), fin);


     // Create second finalization

     CFinalizedBudget fin2("main2 (test)", 144, {txBudgetPayment2, txBudgetPayment}, finTxId2);

     const CFinalizedBudgetVote fvote2(mnVin2, fin2.GetHash());

     const CFinalizedBudgetVote fvote2_a({GetRandHash(), 0}, fin2.GetHash());

     BOOST_CHECK(fin2.AddOrUpdateVote(fvote2, strError));

     BOOST_CHECK(fin2.AddOrUpdateVote(fvote2_a, strError));

     g_budgetman.ForceAddFinalizedBudget(fin2.GetHash(), fin2.GetFeeTXHash(), fin2);

 }


 BOOST_FIXTURE_TEST_CASE(budget_blocks_payee_test, TestChain100Setup)

 {

     // Regtest superblock is every 144 blocks.

     for (int i=0; i<43; i++) CreateAndProcessBlock({}, coinbaseKey);

     enableMnSyncAndSuperblocksPayment();

     g_budgetman.Clear();

     BOOST_CHECK_EQUAL(WITH_LOCK(cs_main, return chainActive.Height();), 143);

     BOOST_ASSERT(g_budgetman.GetFinalizedBudgets().size() == 0);


     // Now we are at the superblock height, let's add a proposal to pay.

     const CScript payee1 = GetScriptForDestination(CKeyID(uint160(ParseHex("816115944e077fe7c803cfa57f29b36bf87c1d35"))));

     const CAmount propAmt1 = 100 * COIN;

     const CScript payee2 = GetScriptForDestination(CKeyID(uint160(ParseHex("8d5b4f83212214d6ef693e02e6d71969fddad976"))));

     const CAmount propAmt2 = propAmt1;

     forceAddFakeProposals({propAmt1, payee1}, {propAmt2, payee2});


     CBlock block = CreateBlock({}, coinbaseKey);

     // Check payee validity:

     CTxOut payeeOut = block.vtx[0]->vout[1];

     BOOST_CHECK_EQUAL(payeeOut.nValue, propAmt1);

     BOOST_CHECK(payeeOut.scriptPubKey == payee1);


     // Good tx

     CMutableTransaction goodMtx(*block.vtx[0]);


     // Modify payee

     CMutableTransaction mtx(*block.vtx[0]);

     mtx.vout[1].scriptPubKey = GetScriptForDestination(CKeyID(uint160(ParseHex("8c988f1a4a4de2161e0f50aac7f17e7f9555caa4"))));

     block.vtx[0] = MakeTransactionRef(mtx);

     std::shared_ptr<CBlock> pblock = FinalizeBlock(std::make_shared<CBlock>(block));

     BOOST_CHECK(block.vtx[0]->vout[1].scriptPubKey != payee1);


     // Verify block rejection reason.

     ProcessBlockAndCheckRejectionReason(pblock, "bad-cb-payee", 143);


     // Try to overmint, valid payee --> bad amount.

     mtx = goodMtx; // reset

     mtx.vout[1].nValue *= 2; // invalid amount

     block.vtx[0] = MakeTransactionRef(mtx);

     pblock = FinalizeBlock(std::make_shared<CBlock>(block));

     BOOST_CHECK(block.vtx[0]->vout[1].scriptPubKey == payee1);

     BOOST_CHECK(block.vtx[0]->vout[1].nValue == payeeOut.nValue * 2);

     ProcessBlockAndCheckRejectionReason(pblock, "bad-blk-amount", 143);


     // Try to send less to a valid payee --> bad amount.

     mtx = goodMtx; // reset

     mtx.vout[1].nValue /= 2;

     block.vtx[0] = MakeTransactionRef(mtx);

     pblock = FinalizeBlock(std::make_shared<CBlock>(block));

     BOOST_CHECK(block.vtx[0]->vout[1].scriptPubKey == payee1);

     BOOST_CHECK(block.vtx[0]->vout[1].nValue == payeeOut.nValue / 2);

     ProcessBlockAndCheckRejectionReason(pblock, "bad-cb-payee", 143);


     // Context, this has:

     // 1) Two proposals and two budget finalizations with a different proposal payment order (read `forceAddFakeProposals()` description):

     //      BudA pays propA and propB, BudB pays propB and propA.

     // 2) Voted both budgets, adding more votes to budA (so it becomes the most voted one).

     // 3) Now: in the superblock, pay to budB order (the less voted finalization) --> which will fail.


     // Try to pay proposals in different order

     mtx = goodMtx; // reset

     std::vector<CFinalizedBudget*> vecFin = g_budgetman.GetFinalizedBudgets();

     CFinalizedBudget* secondFin{nullptr};

     for (auto fin : vecFin) {

         if (!secondFin || fin->GetVoteCount() < secondFin->GetVoteCount()) {

             secondFin = fin;

         }

     }

     secondFin->GetPayeeAndAmount(144, mtx.vout[1].scriptPubKey, mtx.vout[1].nValue);

     BOOST_CHECK(mtx.vout[1].scriptPubKey != goodMtx.vout[1].scriptPubKey);

     BOOST_CHECK(mtx.vout[1].nValue == goodMtx.vout[1].nValue);

     block.vtx[0] = MakeTransactionRef(mtx);

     pblock = FinalizeBlock(std::make_shared<CBlock>(block));

     ProcessBlockAndCheckRejectionReason(pblock, "bad-cb-payee", 143);


     // Now create the good block

     block.vtx[0] = MakeTransactionRef(goodMtx);

     pblock = FinalizeBlock(std::make_shared<CBlock>(block));

     ProcessNewBlock(pblock, nullptr);

     BOOST_CHECK_EQUAL(WITH_LOCK(cs_main, return chainActive.Tip()->GetBlockHash();), pblock->GetHash());

 }


 BOOST_FIXTURE_TEST_CASE(budget_blocks_reorg_test, TestChain100Setup)

 {

     // Regtest superblock is every 144 blocks.

     for (int i=0; i<43; i++) CreateAndProcessBlock({}, coinbaseKey);

     enableMnSyncAndSuperblocksPayment();

     BOOST_CHECK_EQUAL(WITH_LOCK(cs_main, return chainActive.Height();), 143);


     // Now we are at the superblock height, let's add a proposal to pay.

     const CScript payee = GetScriptForDestination(CKeyID(uint160(ParseHex("816115944e077fe7c803cfa57f29b36bf87c1d35"))));

     const CAmount propAmt = 100 * COIN;

     const CScript payee2 = GetScriptForDestination(CKeyID(uint160(ParseHex("816115944e077fe7c803cfa57f29b36bf87c1d35"))));

     const CAmount propAmt2 = propAmt * 2;

     forceAddFakeProposals({propAmt, payee}, {propAmt2, payee2});


     // This will:

     // 1) Create a proposal to be paid at block 144 (first superblock).

     // 1) create blocksA and blockB at block 144 (paying for the proposal).

     // 2) Process and connect blockA.

     // 3) Create blockC on top of BlockA and blockD on top of blockB. At height 145.

     // 4) Process and connect blockC.

     // 5) Now force the reorg:

     //    a) Process blockB and blockD.

     //    b) Create and process blockE on top of blockD.

     // 6) Verify that tip is at blockE.


     CScript forkCoinbaseScript = GetScriptForDestination(CKeyID(uint160(ParseHex("8c988f1a4a4de2161e0f50aac7f17e7f9555caa4"))));

     CBlock blockA = CreateBlock({}, coinbaseKey, false);

     CBlock blockB = CreateBlock({}, forkCoinbaseScript, false);

     BOOST_CHECK(blockA.GetHash() != blockB.GetHash());

     // Check blocks payee validity:

     CTxOut payeeOut = blockA.vtx[0]->vout[1];

     BOOST_CHECK_EQUAL(payeeOut.nValue, propAmt);

     BOOST_CHECK(payeeOut.scriptPubKey == payee);

     payeeOut = blockB.vtx[0]->vout[1];

     BOOST_CHECK_EQUAL(payeeOut.nValue, propAmt);

     BOOST_CHECK(payeeOut.scriptPubKey == payee);


     // Now let's process BlockA:

     auto pblockA = std::make_shared<const CBlock>(blockA);

     ProcessNewBlock(pblockA, nullptr);

     BOOST_CHECK(WITH_LOCK(cs_main, return chainActive.Tip()->GetBlockHash()) == blockA.GetHash());


     // Now let's create blockC on top of BlockA, blockD on top of blockB

     // and process blockC to expand the chain.

     CBlock blockC = CreateBlock({}, coinbaseKey, false);

     BOOST_CHECK(blockC.hashPrevBlock == blockA.GetHash());

     CBlock blockD = CreateBlock({}, forkCoinbaseScript, false);


     // Process and connect blockC

     ProcessNewBlock(std::make_shared<const CBlock>(blockC), nullptr);

     BOOST_CHECK(WITH_LOCK(cs_main, return chainActive.Tip()->GetBlockHash()) == blockC.GetHash());


     // Now let's process the secondary chain

     blockD.hashPrevBlock = blockB.GetHash();

     std::shared_ptr<CBlock> pblockD = FinalizeBlock(std::make_shared<CBlock>(blockD));


     ProcessNewBlock(std::make_shared<const CBlock>(blockB), nullptr);

     ProcessNewBlock(pblockD, nullptr);

     CBlock blockE = CreateBlock({}, forkCoinbaseScript, false);

     blockE.hashPrevBlock = pblockD->GetHash();

     std::shared_ptr<CBlock> pblockE = FinalizeBlock(std::make_shared<CBlock>(blockE));

     ProcessNewBlock(pblockE, nullptr);

     BOOST_CHECK(WITH_LOCK(cs_main, return chainActive.Tip()->GetBlockHash()) == pblockE->GetHash());

 }


 static CScript GetRandomP2PKH()

 {

     CKey key;

     key.MakeNewKey(false);

     return GetScriptForDestination(key.GetPubKey().GetID());

 }


 static CMutableTransaction NewCoinBase(int nHeight, CAmount cbaseAmt, const CScript& cbaseScript)

 {

     CMutableTransaction tx;

     tx.vout.emplace_back(cbaseAmt, cbaseScript);

     tx.vin.emplace_back();

     tx.vin[0].scriptSig = CScript() << nHeight << OP_0;

     return tx;

 }


 BOOST_FIXTURE_TEST_CASE(IsCoinbaseValueValid_test, TestingSetup)

 {

     int nHeight = 100;

     const CAmount mnAmt = GetMasternodePayment(nHeight);

     const CScript& cbaseScript = GetRandomP2PKH();

     CValidationState state;


     // force mnsync complete

     g_tiertwo_sync_state.SetCurrentSyncPhase(MASTERNODE_SYNC_FINISHED);


     // -- Regular blocks


     // Exact

     CMutableTransaction cbase = NewCoinBase(1, mnAmt, cbaseScript);

     BOOST_CHECK(IsCoinbaseValueValid(MakeTransactionRef(cbase), 0, state));

     cbase.vout[0].nValue /= 2;

     cbase.vout.emplace_back(cbase.vout[0]);

     BOOST_CHECK(IsCoinbaseValueValid(MakeTransactionRef(cbase), 0, state));


     // Underpaying with SPORK_8 disabled (good)

     cbase.vout.clear();

     cbase.vout.emplace_back(mnAmt - 1, cbaseScript);

     BOOST_CHECK(IsCoinbaseValueValid(MakeTransactionRef(cbase), 0, state));

     cbase.vout[0].nValue = mnAmt/2;

     cbase.vout.emplace_back(cbase.vout[0]);

     cbase.vout[1].nValue = mnAmt/2 - 1;

     BOOST_CHECK(IsCoinbaseValueValid(MakeTransactionRef(cbase), 0, state));


     // Overpaying with SPORK_8 disabled

     cbase.vout.clear();

     cbase.vout.emplace_back(mnAmt + 1, cbaseScript);

     BOOST_CHECK(!IsCoinbaseValueValid(MakeTransactionRef(cbase), 0, state));

     BOOST_CHECK_EQUAL(state.GetRejectReason(), "bad-cb-amt-spork8-disabled");

     state = CValidationState();

     cbase.vout[0].nValue = mnAmt/2;

     cbase.vout.emplace_back(cbase.vout[0]);

     cbase.vout[1].nValue = mnAmt/2 + 1;

     BOOST_CHECK(!IsCoinbaseValueValid(MakeTransactionRef(cbase), 0, state));

     BOOST_CHECK_EQUAL(state.GetRejectReason(), "bad-cb-amt-spork8-disabled");

     state = CValidationState();


     // enable SPORK_8

     int64_t nTime = GetTime() - 10;

     const CSporkMessage& spork = CSporkMessage(SPORK_8_MASTERNODE_PAYMENT_ENFORCEMENT, nTime + 1, nTime);

     sporkManager.AddOrUpdateSporkMessage(spork);

     BOOST_CHECK(sporkManager.IsSporkActive(SPORK_8_MASTERNODE_PAYMENT_ENFORCEMENT));


     // Underpaying with SPORK_8 enabled

     cbase.vout.clear();

     cbase.vout.emplace_back(mnAmt - 1, cbaseScript);

     BOOST_CHECK(!IsCoinbaseValueValid(MakeTransactionRef(cbase), 0, state));

     BOOST_CHECK_EQUAL(state.GetRejectReason(), "bad-cb-amt");

     state = CValidationState();

     cbase.vout[0].nValue = mnAmt/2;

     cbase.vout.emplace_back(cbase.vout[0]);

     cbase.vout[1].nValue = mnAmt/2 - 1;

     BOOST_CHECK(!IsCoinbaseValueValid(MakeTransactionRef(cbase), 0, state));

     BOOST_CHECK_EQUAL(state.GetRejectReason(), "bad-cb-amt");

     state = CValidationState();


     // Overpaying with SPORK_8 enabled

     cbase.vout.clear();

     cbase.vout.emplace_back(mnAmt + 1, cbaseScript);

     BOOST_CHECK(!IsCoinbaseValueValid(MakeTransactionRef(cbase), 0, state));

     BOOST_CHECK_EQUAL(state.GetRejectReason(), "bad-cb-amt");

     state = CValidationState();

     cbase.vout[0].nValue = mnAmt/2;

     cbase.vout.emplace_back(cbase.vout[0]);

     cbase.vout[1].nValue = mnAmt/2 + 1;

     BOOST_CHECK(!IsCoinbaseValueValid(MakeTransactionRef(cbase), 0, state));

     BOOST_CHECK_EQUAL(state.GetRejectReason(), "bad-cb-amt");

     state = CValidationState();


     const CAmount budgAmt = 200 * COIN;


     // -- Superblocks


     // Exact

     cbase.vout.clear();

     cbase.vout.emplace_back(budgAmt, cbaseScript);

     BOOST_CHECK(IsCoinbaseValueValid(MakeTransactionRef(cbase), budgAmt, state));

     cbase.vout[0].nValue /= 2;

     cbase.vout.emplace_back(cbase.vout[0]);

     BOOST_CHECK(IsCoinbaseValueValid(MakeTransactionRef(cbase), budgAmt, state));


     // Underpaying

     cbase.vout.clear();

     cbase.vout.emplace_back(budgAmt - 1, cbaseScript);

     BOOST_CHECK(!IsCoinbaseValueValid(MakeTransactionRef(cbase), budgAmt, state));

     BOOST_CHECK_EQUAL(state.GetRejectReason(), "bad-superblock-cb-amt");

     state = CValidationState();

     cbase.vout[0].nValue = budgAmt/2;

     cbase.vout.emplace_back(cbase.vout[0]);

     cbase.vout[1].nValue = budgAmt/2 - 1;

     BOOST_CHECK(!IsCoinbaseValueValid(MakeTransactionRef(cbase), budgAmt, state));

     BOOST_CHECK_EQUAL(state.GetRejectReason(), "bad-superblock-cb-amt");

     state = CValidationState();


     // Overpaying

     cbase.vout.clear();

     cbase.vout.emplace_back(budgAmt + 1, cbaseScript);

     BOOST_CHECK(!IsCoinbaseValueValid(MakeTransactionRef(cbase), budgAmt, state));

     BOOST_CHECK_EQUAL(state.GetRejectReason(), "bad-superblock-cb-amt");

     state = CValidationState();

     cbase.vout[0].nValue = budgAmt/2;

     cbase.vout.emplace_back(cbase.vout[0]);

     cbase.vout[1].nValue = budgAmt/2 + 1;

     BOOST_CHECK(!IsCoinbaseValueValid(MakeTransactionRef(cbase), budgAmt, state));

     BOOST_CHECK_EQUAL(state.GetRejectReason(), "bad-superblock-cb-amt");

 }


 BOOST_AUTO_TEST_CASE(fbv_signverify_bls)

 {

     CBLSSecretKey sk1, sk2;

     sk1.MakeNewKey();

     sk2.MakeNewKey();

     BOOST_ASSERT(sk1 != sk2);


     CTxIn vin(COutPoint(uint256S("0000000000000000000000000000000000000000000000000000000000000002"), 0));

     CTxIn vin2(COutPoint(uint256S("000000000000000000000000000000000000000000000000000000000000003"), 0));

     CTxIn vin3(COutPoint(uint256S("0000000000000000000000000000000000000000000000000000000000000002"), 1));


     uint256 budgetHash1 = uint256S("0000000000000000000000000000000000000000000000000000000000000001");

     uint256 budgetHash2 = uint256S("0000000000000000000000000000000000010000000000000000000000000001");


     // Create serialized finalbudgetvote for budgetHash1, signed with sk1

     CFinalizedBudgetVote vote(vin, budgetHash1);

     BOOST_CHECK(vote.Sign(sk1));

     CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);

     ss << vote;


     // Verify received message on pk1

     CFinalizedBudgetVote _vote;

     ss >> _vote;

     BOOST_CHECK(_vote.CheckSignature(sk1.GetPublicKey()));


     // Failing verification on pk2

     BOOST_CHECK(!_vote.CheckSignature(sk2.GetPublicKey()));


     std::vector<unsigned char> sig = _vote.GetVchSig();


     // Failing with different time

     CFinalizedBudgetVote vote1(_vote);

     vote1.SetTime(vote1.GetTime()+1);

     BOOST_CHECK(!vote1.CheckSignature(sk1.GetPublicKey()));


     // Failing with different budget hash

     CFinalizedBudgetVote vote2(vin, budgetHash2);

     vote2.SetTime(_vote.GetTime());

     vote2.SetVchSig(sig);

     BOOST_CHECK(!vote2.CheckSignature(sk1.GetPublicKey()));


     // Failing with different vins: different txid (vin2) or voutn (vin3)

     CFinalizedBudgetVote vote3_1(vin, budgetHash1);

     CFinalizedBudgetVote vote3_2(vin2, budgetHash1);

     CFinalizedBudgetVote vote3_3(vin3, budgetHash1);

     vote3_1.SetTime(_vote.GetTime());

     vote3_2.SetTime(_vote.GetTime());

     vote3_3.SetTime(_vote.GetTime());

     vote3_1.SetVchSig(sig);

     vote3_2.SetVchSig(sig);

     vote3_3.SetVchSig(sig);

     BOOST_CHECK(vote3_1.CheckSignature(sk1.GetPublicKey()));    // vote3_1 == _vote

     BOOST_CHECK(!vote3_2.CheckSignature(sk1.GetPublicKey()));

     BOOST_CHECK(!vote3_3.CheckSignature(sk1.GetPublicKey()));

 }


 BOOST_AUTO_TEST_SUITE_END()

CAmount
int64_t CAmount
Amount in PIV (Can be negative)
Definition: amount.h:13

ProcessBlockAndCheckRejectionReason
void ProcessBlockAndCheckRejectionReason(std::shared_ptr< CBlock > &pblock, const std::string &blockRejectionReason, int expectedChainHeight)
Definition: blocksutil.cpp:13

blocksutil.h

bls_wrapper.h

BOOST_FIXTURE_TEST_CASE
BOOST_FIXTURE_TEST_CASE(block_value, TestnetSetup)
Definition: budget_tests.cpp:76

BOOST_AUTO_TEST_CASE
BOOST_AUTO_TEST_CASE(masternode_value)
Definition: budget_tests.cpp:45

forceAddFakeProposals
void forceAddFakeProposals(const CTxOut &payee1, const CTxOut &payee2)
1) Create two proposals and two budget finalizations with a different proposal payment order: BudA pa...
Definition: budget_tests.cpp:168

enableMnSyncAndSuperblocksPayment
void enableMnSyncAndSuperblocksPayment()
Definition: budget_tests.cpp:29

CheckBudgetValue
void CheckBudgetValue(int nHeight, std::string strNetwork, CAmount nExpectedValue)
Definition: budget_tests.cpp:21

g_budgetman
CBudgetManager g_budgetman
Definition: budgetmanager.cpp:26

budgetmanager.h

UpdateNetworkUpgradeParameters
void UpdateNetworkUpgradeParameters(Consensus::UpgradeIndex idx, int nActivationHeight)
Allows modifying the network upgrade regtest parameters.
Definition: chainparams.cpp:689

SelectParams
void SelectParams(const std::string &network)
Sets the params returned by Params() to those for the given chain name.
Definition: chainparams.cpp:683

Params
const CChainParams & Params()
Return the currently selected parameters.
Definition: chainparams.cpp:666

CBLSSecretKey
Definition: bls_wrapper.h:202

CBLSSecretKey::MakeNewKey
void MakeNewKey()
Definition: bls_wrapper.cpp:54

CBLSSecretKey::GetPublicKey
CBLSPublicKey GetPublicKey() const
Definition: bls_wrapper.cpp:99

CBaseChainParams::REGTEST
static const std::string REGTEST
Definition: chainparamsbase.h:24

CBaseChainParams::TESTNET
static const std::string TESTNET
Definition: chainparamsbase.h:23

CBaseChainParams::MAIN
static const std::string MAIN
Chain name strings.
Definition: chainparamsbase.h:22

CBlockHeader::hashPrevBlock
uint256 hashPrevBlock
Definition: block.h:28

CBlockHeader::GetHash
uint256 GetHash() const
Definition: block.cpp:15

CBlock
Definition: block.h:80

CBlock::vtx
std::vector< CTransactionRef > vtx
Definition: block.h:83

CBlockIndex::GetBlockHash
uint256 GetBlockHash() const
Definition: chain.h:215

CBudgetManager
Definition: budgetmanager.h:21

CBudgetManager::Clear
void Clear()
Definition: budgetmanager.h:158

CBudgetManager::GetTotalBudget
static CAmount GetTotalBudget(int nHeight)
Definition: budgetmanager.cpp:858

CBudgetManager::GetFinalizedBudgets
std::vector< CFinalizedBudget * > GetFinalizedBudgets()
Definition: budgetmanager.cpp:814

CBudgetManager::ForceAddFinalizedBudget
void ForceAddFinalizedBudget(const uint256 &nHash, const uint256 &feeTxId, const CFinalizedBudget &finalizedBudget)
Definition: budgetmanager.cpp:317

CChain::Tip
CBlockIndex * Tip(bool fProofOfStake=false) const
Returns the index entry for the tip of this chain, or nullptr if none.
Definition: chain.h:405

CChain::Height
int Height() const
Return the maximal height in the chain.
Definition: chain.h:450

CChainParams::GetConsensus
const Consensus::Params & GetConsensus() const
Definition: chainparams.h:72

CDataStream
Definition: streams.h:409

CFinalizedBudget
Definition: finalizedbudget.h:31

CFinalizedBudget::GetPayeeAndAmount
bool GetPayeeAndAmount(int64_t nBlockHeight, CScript &payee, CAmount &nAmount) const
Definition: finalizedbudget.cpp:382

CFinalizedBudgetVote
Definition: finalizedbudgetvote.h:20

CFinalizedBudgetVote::GetTime
int64_t GetTime() const
Definition: finalizedbudgetvote.h:43

CFinalizedBudgetVote::SetTime
void SetTime(const int64_t &_nTime)
Definition: finalizedbudgetvote.h:48

CKey
An encapsulated private key.
Definition: key.h:30

CKey::MakeNewKey
void MakeNewKey(bool fCompressed)
Generate a new private key using a cryptographic PRNG.
Definition: key.cpp:158

CKey::GetPubKey
CPubKey GetPubKey() const
Compute the public key from a private key.
Definition: key.cpp:186

CKeyID
A reference to a CKey: the Hash160 of its serialized public key.
Definition: pubkey.h:21

COutPoint
An outpoint - a combination of a transaction hash and an index n into its vout.
Definition: transaction.h:72

CPubKey::GetID
CKeyID GetID() const
Get the KeyID of this public key (hash of its serialization)
Definition: pubkey.h:167

CScript
Serialized script, used inside transaction inputs and outputs.
Definition: script.h:381

CSignedMessage::Sign
bool Sign(const CKey &key, const CKeyID &keyID)
CSignedMessage Class Functions inherited by network signed-messages.
Definition: messagesigner.cpp:115

CSignedMessage::CheckSignature
bool CheckSignature(const CKeyID &keyID) const
Definition: messagesigner.cpp:155

CSignedMessage::GetVchSig
std::vector< unsigned char > GetVchSig() const
Definition: messagesigner.h:88

CSignedMessage::SetVchSig
void SetVchSig(const std::vector< unsigned char > &vchSigIn)
Definition: messagesigner.h:87

CSporkManager::IsSporkActive
bool IsSporkActive(SporkId nSporkID)
Definition: spork.cpp:220

CSporkManager::AddOrUpdateSporkMessage
void AddOrUpdateSporkMessage(const CSporkMessage &spork, bool flush=false)
Definition: spork.cpp:206

CSporkMessage
Definition: spork.h:34

CTxBudgetPayment
Definition: finalizedbudget.h:139

CTxIn
An input of a transaction.
Definition: transaction.h:94

CTxOut
An output of a transaction.
Definition: transaction.h:137

CTxOut::scriptPubKey
CScript scriptPubKey
Definition: transaction.h:140

CTxOut::nValue
CAmount nValue
Definition: transaction.h:139

CValidationState
Capture information about block/transaction validation.
Definition: validation.h:24

CValidationState::GetRejectReason
std::string GetRejectReason() const
Definition: validation.h:94

TierTwoSyncState::SetCurrentSyncPhase
void SetCurrentSyncPhase(int sync_phase)
Definition: tiertwo_sync_state.h:60

uint160
160-bit opaque blob.
Definition: uint256.h:127

uint256
256-bit opaque blob.
Definition: uint256.h:138

BOOST_AUTO_TEST_SUITE
BOOST_AUTO_TEST_SUITE(cuckoocache_tests)
Test Suite for CuckooCache.

BOOST_AUTO_TEST_SUITE_END
BOOST_AUTO_TEST_SUITE_END()

IsBlockValueValid
bool IsBlockValueValid(int nHeight, CAmount &nExpectedValue, CAmount nMinted, CAmount &nBudgetAmt)
Definition: masternode-payments.cpp:197

IsCoinbaseValueValid
bool IsCoinbaseValueValid(const CTransactionRef &tx, CAmount nBudgetAmt, CValidationState &_state)
Check coinbase output value for blocks after v6.0 enforcement.
Definition: masternode-payments.cpp:824

masternode-payments.h

spork
UniValue spork(const JSONRPCRequest &request)
Definition: misc.cpp:286

Consensus::UPGRADE_V5_3
@ UPGRADE_V5_3
Definition: params.h:38

Consensus::UPGRADE_V5_5
@ UPGRADE_V5_5
Definition: params.h:39

Consensus::UPGRADE_ZC_V2
@ UPGRADE_ZC_V2
Definition: params.h:31

std
Definition: uint256.h:212

cs_main
RecursiveMutex cs_main
Global state.
Definition: validation.cpp:80

BOOST_CHECK_EQUAL
#define BOOST_CHECK_EQUAL(v1, v2)
Definition: object.cpp:18

BOOST_CHECK
#define BOOST_CHECK(expr)
Definition: object.cpp:17

GetRandHash
uint256 GetRandHash() noexcept
Definition: random.cpp:596

OP_0
@ OP_0
Definition: script.h:52

SER_NETWORK
@ SER_NETWORK
Definition: serialize.h:174

sporkManager
CSporkManager sporkManager
Definition: spork.cpp:29

spork.h

SPORK_9_MASTERNODE_BUDGET_ENFORCEMENT
@ SPORK_9_MASTERNODE_BUDGET_ENFORCEMENT
Definition: sporkid.h:19

SPORK_13_ENABLE_SUPERBLOCKS
@ SPORK_13_ENABLE_SUPERBLOCKS
Definition: sporkid.h:20

SPORK_8_MASTERNODE_PAYMENT_ENFORCEMENT
@ SPORK_8_MASTERNODE_PAYMENT_ENFORCEMENT
Definition: sporkid.h:18

GetScriptForDestination
CScript GetScriptForDestination(const CTxDestination &dest)
Generate a PIVX scriptPubKey for the given CTxDestination.
Definition: standard.cpp:278

CMutableTransaction
A mutable version of CTransaction.
Definition: transaction.h:409

CMutableTransaction::vout
std::vector< CTxOut > vout
Definition: transaction.h:411

CMutableTransaction::vin
std::vector< CTxIn > vin
Definition: transaction.h:410

Consensus::NetworkUpgrade::ALWAYS_ACTIVE
static constexpr int ALWAYS_ACTIVE
Special value for nActivationHeight indicating that the upgrade is always active.
Definition: params.h:67

Consensus::NetworkUpgrade::nActivationHeight
int nActivationHeight
Height of the first block for which the new consensus rules will be active.
Definition: params.h:56

Consensus::Params::vUpgrades
NetworkUpgrade vUpgrades[MAX_NETWORK_UPGRADES]
Definition: params.h:213

RegTestingSetup
Definition: test_pivx.h:88

TestChain100Setup
Definition: test_pivx.h:123

TestingSetup
Definition: test_pivx.h:71

TestnetSetup
Definition: test_pivx.h:83

WITH_LOCK
#define WITH_LOCK(cs, code)
Run code while locking a mutex.
Definition: sync.h:247

FinalizeBlock
std::shared_ptr< CBlock > FinalizeBlock(std::shared_ptr< CBlock > pblock)
Definition: test_pivx.cpp:239

test_pivx.h

g_tiertwo_sync_state
TierTwoSyncState g_tiertwo_sync_state
Definition: tiertwo_sync_state.cpp:9

tiertwo_sync_state.h

MASTERNODE_SYNC_FINISHED
#define MASTERNODE_SYNC_FINISHED
Definition: tiertwo_sync_state.h:19

tinyformat.h

strprintf
#define strprintf
Definition: tinyformat.h:1056

uint256S
uint256 uint256S(const char *str)
Definition: uint256.h:157

FormatMoney
std::string FormatMoney(const CAmount &n, bool fPlus)
Money parsing/formatting utilities.
Definition: utilmoneystr.cpp:14

utilmoneystr.h

ParseHex
std::vector< unsigned char > ParseHex(const char *psz)
Definition: utilstrencodings.cpp:99

GetTime
int64_t GetTime()
DEPRECATED Use either GetSystemTimeInSeconds (not mockable) or GetTime<T> (mockable)
Definition: utiltime.cpp:27

ProcessNewBlock
bool ProcessNewBlock(const std::shared_ptr< const CBlock > &pblock, const FlatFilePos *dbp)
Process an incoming block.
Definition: validation.cpp:3412

GetMasternodePayment
int64_t GetMasternodePayment(int nHeight)
Definition: validation.cpp:852

GetBlockValue
CAmount GetBlockValue(int nHeight)
Definition: validation.cpp:816

chainActive
CChain chainActive
The currently-connected chain of blocks (protected by cs_main).
Definition: validation.cpp:84