3cff8e9773
Replace test data with Dogecoin equivalents in the folowing tests: * base58 * bip32 * keys * miner * pow Replace RPC and deterministic signatures in unit tests with Dogecoin values. While conventionally I'd use an alternative implementation for these, as RFC 6979 compliant signature generation isn't terribly common, and there's no reason to suspect we've modified this code, I'm going to assert that it's good enough to test that the code doesn't provide different values. Disabled Bitcoin PoW tests, but left code in place to simplify later merges. These are replaced by the Dogecoin PoW tests.
501 lines
23 KiB
C++
501 lines
23 KiB
C++
// Copyright (c) 2011-2016 The Bitcoin Core developers
|
|
// Distributed under the MIT software license, see the accompanying
|
|
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
|
|
|
#include "chainparams.h"
|
|
#include "coins.h"
|
|
#include "consensus/consensus.h"
|
|
#include "consensus/merkle.h"
|
|
#include "consensus/validation.h"
|
|
#include "validation.h"
|
|
#include "miner.h"
|
|
#include "policy/policy.h"
|
|
#include "pubkey.h"
|
|
#include "script/standard.h"
|
|
#include "txmempool.h"
|
|
#include "uint256.h"
|
|
#include "util.h"
|
|
#include "utilstrencodings.h"
|
|
|
|
#include "test/test_bitcoin.h"
|
|
|
|
#include <memory>
|
|
|
|
#include <boost/test/unit_test.hpp>
|
|
|
|
BOOST_FIXTURE_TEST_SUITE(miner_tests, TestingSetup)
|
|
|
|
static CFeeRate blockMinFeeRate = CFeeRate(DEFAULT_BLOCK_MIN_TX_FEE);
|
|
|
|
static
|
|
struct {
|
|
unsigned char extranonce;
|
|
unsigned int nonce;
|
|
} blockinfo[] = {
|
|
{4, 0x127fad2d}, {2, 0x335d1b8f}, {1, 0x33d47094}, {2, 0x0b09ec28},
|
|
{1, 0x06cf723b}, {2, 0x039202bc}, {1, 0x0a2c9d46}, {2, 0x6225cb92},
|
|
{2, 0x6ea1513e}, {1, 0x4401bef3}, {1, 0x04d3a1d2}, {2, 0x1c512825},
|
|
{2, 0x54a03b14}, {1, 0x6048e27d}, {1, 0x1b926afc}, {2, 0x68c4afbd},
|
|
{2, 0x4439c313}, {1, 0x1263fceb}, {2, 0x834dee3e}, {2, 0xf21ed9dc},
|
|
{1, 0xdcdac434}, {2, 0x4c1945be}, {1, 0x6d42a594}, {3, 0x20927a30},
|
|
{3, 0xfd60f461}, {2, 0xd9ad2207}, {2, 0xe7f69d1a}, {1, 0x7fa9b932},
|
|
{2, 0xb0511080}, {1, 0xe7d24cd5}, {2, 0x3c57e668}, {2, 0x83bfdc2e},
|
|
{2, 0x6eeb4e10}, {2, 0x9cacbcfd}, {2, 0xb27ea98e}, {2, 0x6d57c5a7},
|
|
{1, 0x6deb4fa8}, {2, 0xabf625c6}, {2, 0x27e7c569}, {1, 0x89c6e991},
|
|
{2, 0xc359bc28}, {1, 0x6f25768d}, {2, 0x654a4c31}, {1, 0x5cd03bab},
|
|
{1, 0xda405f69}, {3, 0xfea453e5}, {2, 0x137d2c3a}, {5, 0xdee2f36e},
|
|
{1, 0xeccbcf26}, {5, 0x9237dbaa}, {1, 0xb7b9350b}, {1, 0xcd0c7eb2},
|
|
{1, 0xf5ea5a32}, {2, 0x3486a7f3}, {1, 0xd0a0f2be}, {1, 0xe1238144},
|
|
{1, 0x28b98a9b}, {1, 0xe79d02aa}, {5, 0xf4555d56}, {5, 0x74da0bb7},
|
|
{1, 0x18728b91}, {1, 0x07ed3a93}, {6, 0xd7a5e106}, {2, 0xba50b06c},
|
|
{2, 0x952c830d}, {1, 0xfbd1bb18}, {1, 0x36126967}, {1, 0xcce357d0},
|
|
{2, 0xff1ec2d6}, {2, 0xbed5dfc9}, {1, 0x0d21fdd7}, {1, 0xd744edea},
|
|
{1, 0xe09fc8f2}, {5, 0x2ad325c5}, {5, 0x466b6549}, {1, 0x10705d49},
|
|
{1, 0xf88478ce}, {2, 0xbfda6c4a}, {2, 0x731fe414}, {1, 0x6f1b362e},
|
|
{2, 0x6be709cf}, {1, 0x60553200}, {2, 0xf6a992f0}, {2, 0x1521f7f5},
|
|
{1, 0x8b440273}, {1, 0xe9ade0c8}, {1, 0x4d414618}, {5, 0x7b48070d},
|
|
{1, 0x1202ebae}, {1, 0xd23fe97e}, {1, 0x8d1d6505}, {1, 0xfafbaae3},
|
|
{1, 0xf200353e}, {1, 0xe77bd65e}, {1, 0x9fa32102}, {2, 0x68dfa747},
|
|
{0, 0x7c74d78e}, {1, 0x9b79cc6b}, {2, 0xad957cc2}, {2, 0x91acb818}
|
|
};
|
|
|
|
CBlockIndex CreateBlockIndex(int nHeight)
|
|
{
|
|
CBlockIndex index;
|
|
index.nHeight = nHeight;
|
|
index.pprev = chainActive.Tip();
|
|
return index;
|
|
}
|
|
|
|
bool TestSequenceLocks(const CTransaction &tx, int flags)
|
|
{
|
|
LOCK(mempool.cs);
|
|
return CheckSequenceLocks(tx, flags);
|
|
}
|
|
|
|
// Test suite for ancestor feerate transaction selection.
|
|
// Implemented as an additional function, rather than a separate test case,
|
|
// to allow reusing the blockchain created in CreateNewBlock_validity.
|
|
// Note that this test assumes blockprioritysize is 0.
|
|
void TestPackageSelection(const CChainParams& chainparams, CScript scriptPubKey, std::vector<CTransactionRef>& txFirst)
|
|
{
|
|
// Test the ancestor feerate transaction selection.
|
|
TestMemPoolEntryHelper entry;
|
|
|
|
// Test that a medium fee transaction will be selected after a higher fee
|
|
// rate package with a low fee rate parent.
|
|
CMutableTransaction tx;
|
|
tx.vin.resize(1);
|
|
tx.vin[0].scriptSig = CScript() << OP_1;
|
|
tx.vin[0].prevout.hash = txFirst[0]->GetHash();
|
|
tx.vin[0].prevout.n = 0;
|
|
tx.vout.resize(1);
|
|
tx.vout[0].nValue = 5000000000LL - 1000;
|
|
// This tx has a low fee: 1000 satoshis
|
|
uint256 hashParentTx = tx.GetHash(); // save this txid for later use
|
|
mempool.addUnchecked(hashParentTx, entry.Fee(1000).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
|
|
|
|
// This tx has a medium fee: 10000 satoshis
|
|
tx.vin[0].prevout.hash = txFirst[1]->GetHash();
|
|
tx.vout[0].nValue = 5000000000LL - 10000;
|
|
uint256 hashMediumFeeTx = tx.GetHash();
|
|
mempool.addUnchecked(hashMediumFeeTx, entry.Fee(10000).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
|
|
|
|
// This tx has a high fee, but depends on the first transaction
|
|
tx.vin[0].prevout.hash = hashParentTx;
|
|
tx.vout[0].nValue = 5000000000LL - 1000 - 50000; // 50k satoshi fee
|
|
uint256 hashHighFeeTx = tx.GetHash();
|
|
mempool.addUnchecked(hashHighFeeTx, entry.Fee(50000).Time(GetTime()).SpendsCoinbase(false).FromTx(tx));
|
|
|
|
std::unique_ptr<CBlockTemplate> pblocktemplate = BlockAssembler(chainparams).CreateNewBlock(scriptPubKey);
|
|
BOOST_CHECK(pblocktemplate->block.vtx[1]->GetHash() == hashParentTx);
|
|
BOOST_CHECK(pblocktemplate->block.vtx[2]->GetHash() == hashHighFeeTx);
|
|
BOOST_CHECK(pblocktemplate->block.vtx[3]->GetHash() == hashMediumFeeTx);
|
|
|
|
// Test that a package below the block min tx fee doesn't get included
|
|
tx.vin[0].prevout.hash = hashHighFeeTx;
|
|
tx.vout[0].nValue = 5000000000LL - 1000 - 50000; // 0 fee
|
|
uint256 hashFreeTx = tx.GetHash();
|
|
mempool.addUnchecked(hashFreeTx, entry.Fee(0).FromTx(tx));
|
|
size_t freeTxSize = ::GetSerializeSize(tx, SER_NETWORK, PROTOCOL_VERSION);
|
|
|
|
// Calculate a fee on child transaction that will put the package just
|
|
// below the block min tx fee (assuming 1 child tx of the same size).
|
|
CAmount feeToUse = blockMinFeeRate.GetFee(2*freeTxSize) - 1;
|
|
|
|
tx.vin[0].prevout.hash = hashFreeTx;
|
|
tx.vout[0].nValue = 5000000000LL - 1000 - 50000 - feeToUse;
|
|
uint256 hashLowFeeTx = tx.GetHash();
|
|
mempool.addUnchecked(hashLowFeeTx, entry.Fee(feeToUse).FromTx(tx));
|
|
pblocktemplate = BlockAssembler(chainparams).CreateNewBlock(scriptPubKey);
|
|
// Verify that the free tx and the low fee tx didn't get selected
|
|
for (size_t i=0; i<pblocktemplate->block.vtx.size(); ++i) {
|
|
BOOST_CHECK(pblocktemplate->block.vtx[i]->GetHash() != hashFreeTx);
|
|
BOOST_CHECK(pblocktemplate->block.vtx[i]->GetHash() != hashLowFeeTx);
|
|
}
|
|
|
|
// Test that packages above the min relay fee do get included, even if one
|
|
// of the transactions is below the min relay fee
|
|
// Remove the low fee transaction and replace with a higher fee transaction
|
|
mempool.removeRecursive(tx);
|
|
tx.vout[0].nValue -= 2; // Now we should be just over the min relay fee
|
|
hashLowFeeTx = tx.GetHash();
|
|
mempool.addUnchecked(hashLowFeeTx, entry.Fee(feeToUse+2).FromTx(tx));
|
|
pblocktemplate = BlockAssembler(chainparams).CreateNewBlock(scriptPubKey);
|
|
BOOST_CHECK(pblocktemplate->block.vtx[4]->GetHash() == hashFreeTx);
|
|
BOOST_CHECK(pblocktemplate->block.vtx[5]->GetHash() == hashLowFeeTx);
|
|
|
|
// Test that transaction selection properly updates ancestor fee
|
|
// calculations as ancestor transactions get included in a block.
|
|
// Add a 0-fee transaction that has 2 outputs.
|
|
tx.vin[0].prevout.hash = txFirst[2]->GetHash();
|
|
tx.vout.resize(2);
|
|
tx.vout[0].nValue = 5000000000LL - 100000000;
|
|
tx.vout[1].nValue = 100000000; // 1BTC output
|
|
uint256 hashFreeTx2 = tx.GetHash();
|
|
mempool.addUnchecked(hashFreeTx2, entry.Fee(0).SpendsCoinbase(true).FromTx(tx));
|
|
|
|
// This tx can't be mined by itself
|
|
tx.vin[0].prevout.hash = hashFreeTx2;
|
|
tx.vout.resize(1);
|
|
feeToUse = blockMinFeeRate.GetFee(freeTxSize);
|
|
tx.vout[0].nValue = 5000000000LL - 100000000 - feeToUse;
|
|
uint256 hashLowFeeTx2 = tx.GetHash();
|
|
mempool.addUnchecked(hashLowFeeTx2, entry.Fee(feeToUse).SpendsCoinbase(false).FromTx(tx));
|
|
pblocktemplate = BlockAssembler(chainparams).CreateNewBlock(scriptPubKey);
|
|
|
|
// Verify that this tx isn't selected.
|
|
for (size_t i=0; i<pblocktemplate->block.vtx.size(); ++i) {
|
|
BOOST_CHECK(pblocktemplate->block.vtx[i]->GetHash() != hashFreeTx2);
|
|
BOOST_CHECK(pblocktemplate->block.vtx[i]->GetHash() != hashLowFeeTx2);
|
|
}
|
|
|
|
// This tx will be mineable, and should cause hashLowFeeTx2 to be selected
|
|
// as well.
|
|
tx.vin[0].prevout.n = 1;
|
|
tx.vout[0].nValue = 100000000 - 10000; // 10k satoshi fee
|
|
mempool.addUnchecked(tx.GetHash(), entry.Fee(10000).FromTx(tx));
|
|
pblocktemplate = BlockAssembler(chainparams).CreateNewBlock(scriptPubKey);
|
|
BOOST_CHECK(pblocktemplate->block.vtx[8]->GetHash() == hashLowFeeTx2);
|
|
}
|
|
|
|
// NOTE: These tests rely on CreateNewBlock doing its own self-validation!
|
|
BOOST_AUTO_TEST_CASE(CreateNewBlock_validity)
|
|
{
|
|
// Note that by default, these tests run with size accounting enabled.
|
|
const CChainParams& chainparams = Params(CBaseChainParams::MAIN);
|
|
// changed this to dogecoin genesis pubkey script
|
|
CScript scriptPubKey = CScript() << ParseHex("040184710fa689ad5023690c80f3a49c8f13f8d45b8c857fbcbc8bc4a8e4d3eb4b10f4d4604fa08dce601aaf0f470216fe1b51850b4acf21b179c45070ac7b03a9") << OP_CHECKSIG;
|
|
std::unique_ptr<CBlockTemplate> pblocktemplate;
|
|
CMutableTransaction tx,tx2;
|
|
CScript script;
|
|
uint256 hash;
|
|
TestMemPoolEntryHelper entry;
|
|
entry.nFee = 11;
|
|
entry.dPriority = 111.0;
|
|
entry.nHeight = 11;
|
|
|
|
LOCK(cs_main);
|
|
fCheckpointsEnabled = false;
|
|
|
|
// Simple block creation, nothing special yet:
|
|
BOOST_CHECK(pblocktemplate = BlockAssembler(chainparams).CreateNewBlock(scriptPubKey));
|
|
|
|
// We can't make transactions until we have inputs
|
|
// Therefore, load 100 blocks :)
|
|
int baseheight = 0;
|
|
std::vector<CTransactionRef> txFirst;
|
|
for (unsigned int i = 0; i < sizeof(blockinfo)/sizeof(*blockinfo); ++i)
|
|
{
|
|
|
|
CBlock *pblock = &pblocktemplate->block; // pointer for convenience
|
|
pblock->nVersion = 1;
|
|
// Replaced chainActive.Tip()->GetMedianTimePast()+1 with an actual 60 second block
|
|
// interval because median([1,2,2,3,3,3,4,4,4,4]) will eventually be problematic re:
|
|
// block timing. Tests should be more stable than that.
|
|
pblock->nTime = chainActive.Tip()->GetBlockTime() + 60;
|
|
CMutableTransaction txCoinbase(*pblock->vtx[0]);
|
|
txCoinbase.nVersion = 1;
|
|
txCoinbase.vin[0].scriptSig = CScript();
|
|
txCoinbase.vin[0].scriptSig.push_back(blockinfo[i].extranonce);
|
|
txCoinbase.vin[0].scriptSig.push_back(chainActive.Height());
|
|
txCoinbase.vout.resize(1); // Ignore the (optional) segwit commitment added by CreateNewBlock (as the hardcoded nonces don't account for this)
|
|
txCoinbase.vout[0].scriptPubKey = CScript();
|
|
pblock->vtx[0] = MakeTransactionRef(std::move(txCoinbase));
|
|
if (txFirst.size() == 0)
|
|
baseheight = chainActive.Height();
|
|
if (txFirst.size() < 4)
|
|
txFirst.push_back(pblock->vtx[0]);
|
|
pblock->hashMerkleRoot = BlockMerkleRoot(*pblock);
|
|
pblock->nNonce = blockinfo[i].nonce;
|
|
std::shared_ptr<const CBlock> shared_pblock = std::make_shared<const CBlock>(*pblock);
|
|
BOOST_CHECK(ProcessNewBlock(chainparams, shared_pblock, true, NULL));
|
|
pblock->hashPrevBlock = pblock->GetHash();
|
|
}
|
|
|
|
// Just to make sure we can still make simple blocks
|
|
BOOST_CHECK(pblocktemplate = BlockAssembler(chainparams).CreateNewBlock(scriptPubKey));
|
|
|
|
const CAmount BLOCKSUBSIDY = 50*COIN;
|
|
const CAmount LOWFEE = CENT;
|
|
const CAmount HIGHFEE = COIN;
|
|
const CAmount HIGHERFEE = 4*COIN;
|
|
|
|
// block sigops > limit: 1000 CHECKMULTISIG + 1
|
|
tx.vin.resize(1);
|
|
// NOTE: OP_NOP is used to force 20 SigOps for the CHECKMULTISIG
|
|
tx.vin[0].scriptSig = CScript() << OP_0 << OP_0 << OP_0 << OP_NOP << OP_CHECKMULTISIG << OP_1;
|
|
tx.vin[0].prevout.hash = txFirst[0]->GetHash();
|
|
tx.vin[0].prevout.n = 0;
|
|
tx.vout.resize(1);
|
|
tx.vout[0].nValue = BLOCKSUBSIDY;
|
|
for (unsigned int i = 0; i < 1001; ++i)
|
|
{
|
|
tx.vout[0].nValue -= LOWFEE;
|
|
hash = tx.GetHash();
|
|
bool spendsCoinbase = (i == 0) ? true : false; // only first tx spends coinbase
|
|
// If we don't set the # of sig ops in the CTxMemPoolEntry, template creation fails
|
|
mempool.addUnchecked(hash, entry.Fee(LOWFEE).Time(GetTime()).SpendsCoinbase(spendsCoinbase).FromTx(tx));
|
|
tx.vin[0].prevout.hash = hash;
|
|
}
|
|
BOOST_CHECK_THROW(BlockAssembler(chainparams).CreateNewBlock(scriptPubKey), std::runtime_error);
|
|
mempool.clear();
|
|
|
|
tx.vin[0].prevout.hash = txFirst[0]->GetHash();
|
|
tx.vout[0].nValue = BLOCKSUBSIDY;
|
|
for (unsigned int i = 0; i < 1001; ++i)
|
|
{
|
|
tx.vout[0].nValue -= LOWFEE;
|
|
hash = tx.GetHash();
|
|
bool spendsCoinbase = (i == 0) ? true : false; // only first tx spends coinbase
|
|
// If we do set the # of sig ops in the CTxMemPoolEntry, template creation passes
|
|
mempool.addUnchecked(hash, entry.Fee(LOWFEE).Time(GetTime()).SpendsCoinbase(spendsCoinbase).SigOpsCost(80).FromTx(tx));
|
|
tx.vin[0].prevout.hash = hash;
|
|
}
|
|
BOOST_CHECK(pblocktemplate = BlockAssembler(chainparams).CreateNewBlock(scriptPubKey));
|
|
mempool.clear();
|
|
|
|
// block size > limit
|
|
tx.vin[0].scriptSig = CScript();
|
|
// 18 * (520char + DROP) + OP_1 = 9433 bytes
|
|
std::vector<unsigned char> vchData(520);
|
|
for (unsigned int i = 0; i < 18; ++i)
|
|
tx.vin[0].scriptSig << vchData << OP_DROP;
|
|
tx.vin[0].scriptSig << OP_1;
|
|
tx.vin[0].prevout.hash = txFirst[0]->GetHash();
|
|
tx.vout[0].nValue = BLOCKSUBSIDY;
|
|
for (unsigned int i = 0; i < 128; ++i)
|
|
{
|
|
tx.vout[0].nValue -= LOWFEE;
|
|
hash = tx.GetHash();
|
|
bool spendsCoinbase = (i == 0) ? true : false; // only first tx spends coinbase
|
|
mempool.addUnchecked(hash, entry.Fee(LOWFEE).Time(GetTime()).SpendsCoinbase(spendsCoinbase).FromTx(tx));
|
|
tx.vin[0].prevout.hash = hash;
|
|
}
|
|
BOOST_CHECK(pblocktemplate = BlockAssembler(chainparams).CreateNewBlock(scriptPubKey));
|
|
mempool.clear();
|
|
|
|
// orphan in mempool, template creation fails
|
|
hash = tx.GetHash();
|
|
mempool.addUnchecked(hash, entry.Fee(LOWFEE).Time(GetTime()).FromTx(tx));
|
|
BOOST_CHECK_THROW(BlockAssembler(chainparams).CreateNewBlock(scriptPubKey), std::runtime_error);
|
|
mempool.clear();
|
|
|
|
// child with higher priority than parent
|
|
tx.vin[0].scriptSig = CScript() << OP_1;
|
|
tx.vin[0].prevout.hash = txFirst[1]->GetHash();
|
|
tx.vout[0].nValue = BLOCKSUBSIDY-HIGHFEE;
|
|
hash = tx.GetHash();
|
|
mempool.addUnchecked(hash, entry.Fee(HIGHFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
|
|
tx.vin[0].prevout.hash = hash;
|
|
tx.vin.resize(2);
|
|
tx.vin[1].scriptSig = CScript() << OP_1;
|
|
tx.vin[1].prevout.hash = txFirst[0]->GetHash();
|
|
tx.vin[1].prevout.n = 0;
|
|
tx.vout[0].nValue = tx.vout[0].nValue+BLOCKSUBSIDY-HIGHERFEE; //First txn output + fresh coinbase - new txn fee
|
|
hash = tx.GetHash();
|
|
mempool.addUnchecked(hash, entry.Fee(HIGHERFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
|
|
BOOST_CHECK(pblocktemplate = BlockAssembler(chainparams).CreateNewBlock(scriptPubKey));
|
|
mempool.clear();
|
|
|
|
// coinbase in mempool, template creation fails
|
|
tx.vin.resize(1);
|
|
tx.vin[0].prevout.SetNull();
|
|
tx.vin[0].scriptSig = CScript() << OP_0 << OP_1;
|
|
tx.vout[0].nValue = 0;
|
|
hash = tx.GetHash();
|
|
// give it a fee so it'll get mined
|
|
mempool.addUnchecked(hash, entry.Fee(LOWFEE).Time(GetTime()).SpendsCoinbase(false).FromTx(tx));
|
|
BOOST_CHECK_THROW(BlockAssembler(chainparams).CreateNewBlock(scriptPubKey), std::runtime_error);
|
|
mempool.clear();
|
|
|
|
// invalid (pre-p2sh) txn in mempool, template creation fails
|
|
tx.vin[0].prevout.hash = txFirst[0]->GetHash();
|
|
tx.vin[0].prevout.n = 0;
|
|
tx.vin[0].scriptSig = CScript() << OP_1;
|
|
tx.vout[0].nValue = BLOCKSUBSIDY-LOWFEE;
|
|
script = CScript() << OP_0;
|
|
tx.vout[0].scriptPubKey = GetScriptForDestination(CScriptID(script));
|
|
hash = tx.GetHash();
|
|
mempool.addUnchecked(hash, entry.Fee(LOWFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
|
|
tx.vin[0].prevout.hash = hash;
|
|
tx.vin[0].scriptSig = CScript() << std::vector<unsigned char>(script.begin(), script.end());
|
|
tx.vout[0].nValue -= LOWFEE;
|
|
hash = tx.GetHash();
|
|
mempool.addUnchecked(hash, entry.Fee(LOWFEE).Time(GetTime()).SpendsCoinbase(false).FromTx(tx));
|
|
BOOST_CHECK_THROW(BlockAssembler(chainparams).CreateNewBlock(scriptPubKey), std::runtime_error);
|
|
mempool.clear();
|
|
|
|
// double spend txn pair in mempool, template creation fails
|
|
tx.vin[0].prevout.hash = txFirst[0]->GetHash();
|
|
tx.vin[0].scriptSig = CScript() << OP_1;
|
|
tx.vout[0].nValue = BLOCKSUBSIDY-HIGHFEE;
|
|
tx.vout[0].scriptPubKey = CScript() << OP_1;
|
|
hash = tx.GetHash();
|
|
mempool.addUnchecked(hash, entry.Fee(HIGHFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
|
|
tx.vout[0].scriptPubKey = CScript() << OP_2;
|
|
hash = tx.GetHash();
|
|
mempool.addUnchecked(hash, entry.Fee(HIGHFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
|
|
BOOST_CHECK_THROW(BlockAssembler(chainparams).CreateNewBlock(scriptPubKey), std::runtime_error);
|
|
mempool.clear();
|
|
|
|
// subsidy changing
|
|
int nHeight = chainActive.Height();
|
|
// Create an actual 209999-long block chain (without valid blocks).
|
|
while (chainActive.Tip()->nHeight < 209999) {
|
|
CBlockIndex* prev = chainActive.Tip();
|
|
CBlockIndex* next = new CBlockIndex();
|
|
next->phashBlock = new uint256(GetRandHash());
|
|
pcoinsTip->SetBestBlock(next->GetBlockHash());
|
|
next->pprev = prev;
|
|
next->nHeight = prev->nHeight + 1;
|
|
next->BuildSkip();
|
|
chainActive.SetTip(next);
|
|
}
|
|
BOOST_CHECK(pblocktemplate = BlockAssembler(chainparams).CreateNewBlock(scriptPubKey));
|
|
// Extend to a 210000-long block chain.
|
|
while (chainActive.Tip()->nHeight < 210000) {
|
|
CBlockIndex* prev = chainActive.Tip();
|
|
CBlockIndex* next = new CBlockIndex();
|
|
next->phashBlock = new uint256(GetRandHash());
|
|
pcoinsTip->SetBestBlock(next->GetBlockHash());
|
|
next->pprev = prev;
|
|
next->nHeight = prev->nHeight + 1;
|
|
next->BuildSkip();
|
|
chainActive.SetTip(next);
|
|
}
|
|
BOOST_CHECK(pblocktemplate = BlockAssembler(chainparams).CreateNewBlock(scriptPubKey));
|
|
// Delete the dummy blocks again.
|
|
while (chainActive.Tip()->nHeight > nHeight) {
|
|
CBlockIndex* del = chainActive.Tip();
|
|
chainActive.SetTip(del->pprev);
|
|
pcoinsTip->SetBestBlock(del->pprev->GetBlockHash());
|
|
delete del->phashBlock;
|
|
delete del;
|
|
}
|
|
|
|
// non-final txs in mempool
|
|
// changed to 60 second block interval for consistency
|
|
SetMockTime(chainActive.Tip()->GetBlockTime()+60);
|
|
int flags = LOCKTIME_VERIFY_SEQUENCE|LOCKTIME_MEDIAN_TIME_PAST;
|
|
// height map
|
|
std::vector<int> prevheights;
|
|
|
|
// relative height locked
|
|
tx.nVersion = 2;
|
|
tx.vin.resize(1);
|
|
prevheights.resize(1);
|
|
tx.vin[0].prevout.hash = txFirst[0]->GetHash(); // only 1 transaction
|
|
tx.vin[0].prevout.n = 0;
|
|
tx.vin[0].scriptSig = CScript() << OP_1;
|
|
tx.vin[0].nSequence = chainActive.Tip()->nHeight + 1; // txFirst[0] is the 2nd block
|
|
prevheights[0] = baseheight + 1;
|
|
tx.vout.resize(1);
|
|
tx.vout[0].nValue = BLOCKSUBSIDY-HIGHFEE;
|
|
tx.vout[0].scriptPubKey = CScript() << OP_1;
|
|
tx.nLockTime = 0;
|
|
hash = tx.GetHash();
|
|
mempool.addUnchecked(hash, entry.Fee(HIGHFEE).Time(GetTime()).SpendsCoinbase(true).FromTx(tx));
|
|
BOOST_CHECK(CheckFinalTx(tx, flags)); // Locktime passes
|
|
BOOST_CHECK(!TestSequenceLocks(tx, flags)); // Sequence locks fail
|
|
BOOST_CHECK(SequenceLocks(tx, flags, &prevheights, CreateBlockIndex(chainActive.Tip()->nHeight + 2))); // Sequence locks pass on 2nd block
|
|
|
|
// relative time locked
|
|
tx.vin[0].prevout.hash = txFirst[1]->GetHash();
|
|
tx.vin[0].nSequence = CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG | (((chainActive.Tip()->GetMedianTimePast()+1-chainActive[1]->GetMedianTimePast()) >> CTxIn::SEQUENCE_LOCKTIME_GRANULARITY) + 1); // txFirst[1] is the 3rd block
|
|
prevheights[0] = baseheight + 2;
|
|
hash = tx.GetHash();
|
|
mempool.addUnchecked(hash, entry.Time(GetTime()).FromTx(tx));
|
|
BOOST_CHECK(CheckFinalTx(tx, flags)); // Locktime passes
|
|
BOOST_CHECK(!TestSequenceLocks(tx, flags)); // Sequence locks fail
|
|
|
|
for (int i = 0; i < CBlockIndex::nMedianTimeSpan; i++)
|
|
chainActive.Tip()->GetAncestor(chainActive.Tip()->nHeight - i)->nTime += 512; //Trick the MedianTimePast
|
|
BOOST_CHECK(SequenceLocks(tx, flags, &prevheights, CreateBlockIndex(chainActive.Tip()->nHeight + 1))); // Sequence locks pass 512 seconds later
|
|
for (int i = 0; i < CBlockIndex::nMedianTimeSpan; i++)
|
|
chainActive.Tip()->GetAncestor(chainActive.Tip()->nHeight - i)->nTime -= 512; //undo tricked MTP
|
|
|
|
// absolute height locked
|
|
tx.vin[0].prevout.hash = txFirst[2]->GetHash();
|
|
tx.vin[0].nSequence = CTxIn::SEQUENCE_FINAL - 1;
|
|
prevheights[0] = baseheight + 3;
|
|
tx.nLockTime = chainActive.Tip()->nHeight + 1;
|
|
hash = tx.GetHash();
|
|
mempool.addUnchecked(hash, entry.Time(GetTime()).FromTx(tx));
|
|
BOOST_CHECK(!CheckFinalTx(tx, flags)); // Locktime fails
|
|
BOOST_CHECK(TestSequenceLocks(tx, flags)); // Sequence locks pass
|
|
BOOST_CHECK(IsFinalTx(tx, chainActive.Tip()->nHeight + 2, chainActive.Tip()->GetMedianTimePast())); // Locktime passes on 2nd block
|
|
|
|
// absolute time locked
|
|
tx.vin[0].prevout.hash = txFirst[3]->GetHash();
|
|
tx.nLockTime = chainActive.Tip()->GetMedianTimePast();
|
|
prevheights.resize(1);
|
|
prevheights[0] = baseheight + 4;
|
|
hash = tx.GetHash();
|
|
mempool.addUnchecked(hash, entry.Time(GetTime()).FromTx(tx));
|
|
BOOST_CHECK(!CheckFinalTx(tx, flags)); // Locktime fails
|
|
BOOST_CHECK(TestSequenceLocks(tx, flags)); // Sequence locks pass
|
|
BOOST_CHECK(IsFinalTx(tx, chainActive.Tip()->nHeight + 2, chainActive.Tip()->GetMedianTimePast() + 1)); // Locktime passes 1 second later
|
|
|
|
// mempool-dependent transactions (not added)
|
|
tx.vin[0].prevout.hash = hash;
|
|
prevheights[0] = chainActive.Tip()->nHeight + 1;
|
|
tx.nLockTime = 0;
|
|
tx.vin[0].nSequence = 0;
|
|
BOOST_CHECK(CheckFinalTx(tx, flags)); // Locktime passes
|
|
BOOST_CHECK(TestSequenceLocks(tx, flags)); // Sequence locks pass
|
|
tx.vin[0].nSequence = 1;
|
|
BOOST_CHECK(!TestSequenceLocks(tx, flags)); // Sequence locks fail
|
|
tx.vin[0].nSequence = CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG;
|
|
BOOST_CHECK(TestSequenceLocks(tx, flags)); // Sequence locks pass
|
|
tx.vin[0].nSequence = CTxIn::SEQUENCE_LOCKTIME_TYPE_FLAG | 1;
|
|
BOOST_CHECK(!TestSequenceLocks(tx, flags)); // Sequence locks fail
|
|
|
|
BOOST_CHECK(pblocktemplate = BlockAssembler(chainparams).CreateNewBlock(scriptPubKey));
|
|
|
|
// None of the of the absolute height/time locked tx should have made
|
|
// it into the template because we still check IsFinalTx in CreateNewBlock,
|
|
// but relative locked txs will if inconsistently added to mempool.
|
|
// For now these will still generate a valid template until BIP68 soft fork
|
|
BOOST_CHECK_EQUAL(pblocktemplate->block.vtx.size(), 3);
|
|
// However if we advance height by 1 and time by 512, all of them should be mined
|
|
for (int i = 0; i < CBlockIndex::nMedianTimeSpan; i++)
|
|
chainActive.Tip()->GetAncestor(chainActive.Tip()->nHeight - i)->nTime += 512; //Trick the MedianTimePast
|
|
chainActive.Tip()->nHeight++;
|
|
// changed to 60 second block interval for consistency
|
|
SetMockTime(chainActive.Tip()->GetBlockTime() + 60);
|
|
|
|
BOOST_CHECK(pblocktemplate = BlockAssembler(chainparams).CreateNewBlock(scriptPubKey));
|
|
BOOST_CHECK_EQUAL(pblocktemplate->block.vtx.size(), 5);
|
|
|
|
chainActive.Tip()->nHeight--;
|
|
SetMockTime(0);
|
|
mempool.clear();
|
|
|
|
TestPackageSelection(chainparams, scriptPubKey, txFirst);
|
|
|
|
fCheckpointsEnabled = true;
|
|
}
|
|
|
|
BOOST_AUTO_TEST_SUITE_END()
|