bool TxIndex::FindTx(const uint256& tx_hash, uint256& block_hash, CTransactionRef& tx) const
{
CDiskTxPos postx;
if (!m_db->ReadTxPos(tx_hash, postx)) {
return false;
}
CAutoFile file(OpenBlockFile(postx, true), SER_DISK, CLIENT_VERSION);
if (file.IsNull()) {
return error("%s: OpenBlockFile failed", __func__);
}
CBlockHeader header;
try {
file >> header;
if (fseek(file.Get(), postx.nTxOffset, SEEK_CUR)) {
return error("%s: fseek(...) failed", __func__);
}
file >> tx;
} catch (const std::exception& e) {
return error("%s: Deserialize or I/O error - %s", __func__, e.what());
}
if (tx->GetHash() != tx_hash) {
return error("%s: txid mismatch", __func__);
}
block_hash = header.GetHash();
return true;
}
// SYSCOIN moved and added auxpow check
CBlockHeader CBlockIndex::GetBlockHeader(const Consensus::Params& consensusParams) const
{
CBlockHeader block;
block.nVersion = nVersion;
/* The CBlockIndex object's block header is missing the auxpow.
So if this is an auxpow block, read it from disk instead. We only
have to read the actual *header*, not the full block. */
if (block.IsAuxpow())
{
ReadBlockHeaderFromDisk(block, this, consensusParams);
return block;
}
if (pprev)
block.hashPrevBlock = pprev->GetBlockHash();
block.hashMerkleRoot = hashMerkleRoot;
block.nTime = nTime;
block.nBits = nBits;
block.nNonce = nNonce;
return block;
}
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;
}
/**
* Mine a block (assuming minimal difficulty) that either matches
* or doesn't match the difficulty target specified in the block header.
* @param block The block to mine (by updating nonce).
* @param ok Whether the block should be ok for PoW.
* @param nBits Use this as difficulty if specified.
*/
static void
mineBlock (CBlockHeader& block, bool ok, int nBits = -1)
{
if (nBits == -1)
nBits = block.nBits;
arith_uint256 target;
target.SetCompact (nBits);
block.nNonce = 0;
while (true)
{
const bool nowOk = (UintToArith256 (block.GetHash ()) <= target);
if ((ok && nowOk) || (!ok && !nowOk))
break;
++block.nNonce;
}
if (ok)
BOOST_CHECK (CheckProofOfWork (block.GetHash (), nBits, Params().GetConsensus()));
else
BOOST_CHECK (!CheckProofOfWork (block.GetHash (), nBits, Params().GetConsensus()));
}
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));
}
uint256 GetPoWAlgoHash(const CBlockHeader& block)
{
return block.GetPoWAlgoHash(Params().GetConsensus());
}