void
CAuxPow::initAuxPow (CBlockHeader& header)
{
/* Set auxpow flag right now, since we take the block hash below. */
header.SetAuxpowVersion(true);
/* Build a minimal coinbase script input for merge-mining. */
const uint256 blockHash = header.GetHash ();
valtype inputData(blockHash.begin (), blockHash.end ());
std::reverse (inputData.begin (), inputData.end ());
inputData.push_back (1);
inputData.insert (inputData.end (), 7, 0);
/* Fake a parent-block coinbase with just the required input
script and no outputs. */
CMutableTransaction coinbase;
coinbase.vin.resize (1);
coinbase.vin[0].prevout.SetNull ();
coinbase.vin[0].scriptSig = (CScript () << inputData);
assert (coinbase.vout.empty ());
CTransactionRef coinbaseRef = MakeTransactionRef (coinbase);
/* Build a fake parent block with the coinbase. */
CBlock parent;
parent.nVersion = 1;
parent.vtx.resize (1);
parent.vtx[0] = coinbaseRef;
parent.hashMerkleRoot = BlockMerkleRoot (parent);
/* Construct the auxpow object. */
header.SetAuxpow (new CAuxPow (coinbaseRef));
assert (header.auxpow->vChainMerkleBranch.empty ());
header.auxpow->nChainIndex = 0;
assert (header.auxpow->vMerkleBranch.empty ());
header.auxpow->nIndex = 0;
header.auxpow->parentBlock = parent;
}
BOOST_FIXTURE_TEST_CASE (auxpow_pow, BasicTestingSetup)
{
/* Use regtest parameters to allow mining with easy difficulty. */
SelectParams (CBaseChainParams::REGTEST);
const Consensus::Params& params = Params ().GetConsensus ();
const arith_uint256 target = (~arith_uint256 (0) >> 1);
CBlockHeader block;
block.nBits = target.GetCompact ();
/* Verify the block version checks. */
block.nVersion = 1;
mineBlock (block, true);
BOOST_CHECK (CheckProofOfWork (block, params));
block.nVersion = 2;
mineBlock (block, true);
BOOST_CHECK (!CheckProofOfWork (block, params));
block.SetBaseVersion (2, params.nAuxpowChainId);
mineBlock (block, true);
BOOST_CHECK (CheckProofOfWork (block, params));
block.SetChainId (params.nAuxpowChainId + 1);
mineBlock (block, true);
BOOST_CHECK (!CheckProofOfWork (block, params));
/* Check the case when the block does not have auxpow (this is true
right now). */
block.SetChainId (params.nAuxpowChainId);
block.SetAuxpowVersion (true);
mineBlock (block, true);
BOOST_CHECK (!CheckProofOfWork (block, params));
block.SetAuxpowVersion (false);
mineBlock (block, true);
BOOST_CHECK (CheckProofOfWork (block, params));
mineBlock (block, false);
BOOST_CHECK (!CheckProofOfWork (block, params));
/* ****************************************** */
/* Check the case that the block has auxpow. */
CAuxpowBuilder builder(5, 42);
CAuxPow auxpow;
const int32_t ourChainId = params.nAuxpowChainId;
const unsigned height = 3;
const int nonce = 7;
const int index = CAuxPow::getExpectedIndex (nonce, ourChainId, height);
valtype auxRoot, data;
/* Valid auxpow, PoW check of parent block. */
block.SetAuxpowVersion (true);
auxRoot = builder.buildAuxpowChain (block.GetHash (), height, index);
data = CAuxpowBuilder::buildCoinbaseData (true, auxRoot, height, nonce);
builder.setCoinbase (CScript () << data);
mineBlock (builder.parentBlock, false, block.nBits);
block.SetAuxpow (builder.getUnique ());
BOOST_CHECK (!CheckProofOfWork (block, params));
mineBlock (builder.parentBlock, true, block.nBits);
block.SetAuxpow (builder.getUnique ());
BOOST_CHECK (CheckProofOfWork (block, params));
/* Mismatch between auxpow being present and block.nVersion. Note that
block.SetAuxpow sets also the version and that we want to ensure
that the block hash itself doesn't change due to version changes.
This requires some work arounds. */
block.SetAuxpowVersion (false);
const uint256 hashAux = block.GetHash ();
auxRoot = builder.buildAuxpowChain (hashAux, height, index);
data = CAuxpowBuilder::buildCoinbaseData (true, auxRoot, height, nonce);
builder.setCoinbase (CScript () << data);
mineBlock (builder.parentBlock, true, block.nBits);
block.SetAuxpow (builder.getUnique ());
BOOST_CHECK (hashAux != block.GetHash ());
block.SetAuxpowVersion (false);
BOOST_CHECK (hashAux == block.GetHash ());
BOOST_CHECK (!CheckProofOfWork (block, params));
/* Modifying the block invalidates the PoW. */
block.SetAuxpowVersion (true);
auxRoot = builder.buildAuxpowChain (block.GetHash (), height, index);
data = CAuxpowBuilder::buildCoinbaseData (true, auxRoot, height, nonce);
builder.setCoinbase (CScript () << data);
mineBlock (builder.parentBlock, true, block.nBits);
block.SetAuxpow (builder.getUnique ());
BOOST_CHECK (CheckProofOfWork (block, params));
tamperWith (block.hashMerkleRoot);
BOOST_CHECK (!CheckProofOfWork (block, params));
}
