bc8cca4896
Changes are as below: Wrap CBlockHeader::nVersion into a new class (CBlockVersion). This allows to take care of interpreting the field into a base version, auxpow flag and the chain ID. Update getauxblock.py for new 'generate' RPC call. Add 'auxpow' to block JSON. Accept auxpow as PoW verification. Add unit tests for auxpow verification. Add check for memory-layout of CBlockVersion. Weaken auxpow chain ID checks for the testnet. Allow Params() to overrule when to check the auxpow chain ID and for legacy blocks. Use this to disable the checks on testnet. Introduce CPureBlockHeader. Split the block header part that is used by auxpow and the "real" block header (that uses auxpow) to resolve the cyclic dependency between the two. Differentiate between uint256 and arith_uint256. This change was done upstream, modify the auxpow code. Add missing lock in auxpow_tests. Fix REST header check for auxpow headers. Those can be longer, thus take that into account. Also perform the check actually on an auxpow header. Correctly set the coinbase for getauxblock results. Call IncrementExtraNonce in getauxblock so that the coinbase is actually initialised with the stuff it should be. (BIP30 block height and COINBASE_FLAGS.) Implement getauxblock plus regression test. Turn auxpow test into FIXTURE test. This allows using of the Params() calls. Move CMerkleTx code to auxpow.cpp. Otherwise we get linker errors when building without wallet. Fix rebase with BIP66. Update the code to handle BIP66's nVersion=3. Enforce that auxpow parent blocks have no auxpow block version. This is for compatibility with namecoind. See also https://github.com/namecoin/namecoin/pull/199. Move auxpow-related parameters to Consensus::Params.
498 lines
23 KiB
C++
498 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;
|
|
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()
|