blockencodings__tests_8cpp_source.html

// Copyright (c) 2011-present 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 <blockencodings.h>

#include <chainparams.h>

#include <consensus/merkle.h>

#include <pow.h>

#include <streams.h>

#include <test/util/random.h>

#include <test/util/txmempool.h>


#include <test/util/common.h>

#include <test/util/setup_common.h>


#include <boost/test/unit_test.hpp>


const std::vector<std::pair<Wtxid, CTransactionRef>> empty_extra_txn;


BOOST_FIXTURE_TEST_SUITE(blockencodings_tests, RegTestingSetup)


static CMutableTransaction BuildTransactionTestCase() {

    CMutableTransaction tx;

    tx.vin.resize(1);

    tx.vin[0].scriptSig.resize(10);

    tx.vout.resize(1);

    tx.vout[0].nValue = 42;

    return tx;

}


static CBlock BuildBlockTestCase(FastRandomContext& ctx) {

    CBlock block;

    CMutableTransaction tx = BuildTransactionTestCase();


    block.vtx.resize(3);

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

    block.nVersion = 42;

    block.hashPrevBlock = ctx.rand256();

    block.nBits = 0x207fffff;


    tx.vin[0].prevout.hash = Txid::FromUint256(ctx.rand256());

    tx.vin[0].prevout.n = 0;

    block.vtx[1] = MakeTransactionRef(tx);


    tx.vin.resize(10);

    for (size_t i = 0; i < tx.vin.size(); i++) {

        tx.vin[i].prevout.hash = Txid::FromUint256(ctx.rand256());

        tx.vin[i].prevout.n = 0;

    }

    block.vtx[2] = MakeTransactionRef(tx);


    bool mutated;

    block.hashMerkleRoot = BlockMerkleRoot(block, &mutated);

    assert(!mutated);

    while (!CheckProofOfWork(block.GetHash(), block.nBits, Params().GetConsensus())) ++block.nNonce;

    return block;

}


// Number of shared use_counts we expect for a tx we haven't touched

// (block + mempool entry + our copy from the GetSharedTx call)

constexpr long SHARED_TX_OFFSET{3};


BOOST_AUTO_TEST_CASE(SimpleRoundTripTest)

{

    CTxMemPool& pool = *Assert(m_node.mempool);

    TestMemPoolEntryHelper entry;

    auto rand_ctx(FastRandomContext(uint256{42}));

    CBlock block(BuildBlockTestCase(rand_ctx));


    LOCK2(cs_main, pool.cs);

    TryAddToMempool(pool, entry.FromTx(block.vtx[2]));

    BOOST_CHECK_EQUAL(pool.get(block.vtx[2]->GetHash()).use_count(), SHARED_TX_OFFSET + 0);


    // Do a simple ShortTxIDs RT

    {

        CBlockHeaderAndShortTxIDs shortIDs{block, rand_ctx.rand64()};


        DataStream stream{};

        stream << shortIDs;


        CBlockHeaderAndShortTxIDs shortIDs2;

        stream >> shortIDs2;


        PartiallyDownloadedBlock partialBlock(&pool);

        BOOST_CHECK(partialBlock.InitData(shortIDs2, empty_extra_txn) == READ_STATUS_OK);

        BOOST_CHECK( partialBlock.IsTxAvailable(0));

        BOOST_CHECK(!partialBlock.IsTxAvailable(1));

        BOOST_CHECK( partialBlock.IsTxAvailable(2));


        BOOST_CHECK_EQUAL(pool.get(block.vtx[2]->GetHash()).use_count(), SHARED_TX_OFFSET + 1);


        size_t poolSize = pool.size();

        pool.removeRecursive(*block.vtx[2], MemPoolRemovalReason::REPLACED);

        BOOST_CHECK_EQUAL(pool.size(), poolSize - 1);


        CBlock block2;

        {

            PartiallyDownloadedBlock tmp = partialBlock;

            BOOST_CHECK(partialBlock.FillBlock(block2, {}, /*segwit_active=*/true) == READ_STATUS_INVALID); // No transactions

            partialBlock = tmp;

        }


        // Wrong transaction

        {

            PartiallyDownloadedBlock tmp = partialBlock;

            partialBlock.FillBlock(block2, {block.vtx[2]}, /*segwit_active=*/true); // Current implementation doesn't check txn here, but don't require that

            partialBlock = tmp;

        }

        bool mutated;

        BOOST_CHECK(block.hashMerkleRoot != BlockMerkleRoot(block2, &mutated));


        CBlock block3;

        BOOST_CHECK(partialBlock.FillBlock(block3, {block.vtx[1]}, /*segwit_active=*/true) == READ_STATUS_OK);

        BOOST_CHECK_EQUAL(block.GetHash().ToString(), block3.GetHash().ToString());

        BOOST_CHECK_EQUAL(block.hashMerkleRoot.ToString(), BlockMerkleRoot(block3, &mutated).ToString());

        BOOST_CHECK(!mutated);

    }

}


class TestHeaderAndShortIDs {

    // Utility to encode custom CBlockHeaderAndShortTxIDs

public:

    CBlockHeader header;

    uint64_t nonce;

    std::vector<uint64_t> shorttxids;

    std::vector<PrefilledTransaction> prefilledtxn;


    explicit TestHeaderAndShortIDs(const CBlockHeaderAndShortTxIDs& orig) {

        DataStream stream{};

        stream << orig;

        stream >> *this;

    }


    explicit TestHeaderAndShortIDs(const CBlock& block, FastRandomContext& ctx) :

        TestHeaderAndShortIDs(CBlockHeaderAndShortTxIDs{block, ctx.rand64()}) {}


    uint64_t GetShortID(const Wtxid& txhash) const {

        DataStream stream{};

        stream << *this;

        CBlockHeaderAndShortTxIDs base;

        stream >> base;

        return base.GetShortID(txhash);

    }


    SERIALIZE_METHODS(TestHeaderAndShortIDs, obj) { READWRITE(obj.header, obj.nonce, Using<VectorFormatter<CustomUintFormatter<CBlockHeaderAndShortTxIDs::SHORTTXIDS_LENGTH>>>(obj.shorttxids), obj.prefilledtxn); }

};


struct TestPartiallyDownloadedBlock : PartiallyDownloadedBlock {

    using PartiallyDownloadedBlock::PartiallyDownloadedBlock;


    size_t GetMempoolCount() const { return mempool_count; }

    size_t GetExtraCount() const { return extra_count; }

};


BOOST_AUTO_TEST_CASE(NonCoinbasePreforwardRTTest)

{

    CTxMemPool& pool = *Assert(m_node.mempool);

    TestMemPoolEntryHelper entry;

    auto rand_ctx(FastRandomContext(uint256{42}));

    CBlock block(BuildBlockTestCase(rand_ctx));


    LOCK2(cs_main, pool.cs);

    TryAddToMempool(pool, entry.FromTx(block.vtx[2]));

    BOOST_CHECK_EQUAL(pool.get(block.vtx[2]->GetHash()).use_count(), SHARED_TX_OFFSET + 0);


    Txid txhash;


    // Test with pre-forwarding tx 1, but not coinbase

    {

        TestHeaderAndShortIDs shortIDs(block, rand_ctx);

        shortIDs.prefilledtxn.resize(1);

        shortIDs.prefilledtxn[0] = {1, block.vtx[1]};

        shortIDs.shorttxids.resize(2);

        shortIDs.shorttxids[0] = shortIDs.GetShortID(block.vtx[0]->GetWitnessHash());

        shortIDs.shorttxids[1] = shortIDs.GetShortID(block.vtx[2]->GetWitnessHash());


        DataStream stream{};

        stream << shortIDs;


        CBlockHeaderAndShortTxIDs shortIDs2;

        stream >> shortIDs2;


        PartiallyDownloadedBlock partialBlock(&pool);

        BOOST_CHECK(partialBlock.InitData(shortIDs2, empty_extra_txn) == READ_STATUS_OK);

        BOOST_CHECK(!partialBlock.IsTxAvailable(0));

        BOOST_CHECK( partialBlock.IsTxAvailable(1));

        BOOST_CHECK( partialBlock.IsTxAvailable(2));


        BOOST_CHECK_EQUAL(pool.get(block.vtx[2]->GetHash()).use_count(), SHARED_TX_OFFSET + 1); // +1 because of partialBlock


        CBlock block2;

        {

            PartiallyDownloadedBlock tmp = partialBlock;

            BOOST_CHECK(partialBlock.FillBlock(block2, {}, /*segwit_active=*/true) == READ_STATUS_INVALID); // No transactions

            partialBlock = tmp;

        }


        // Wrong transaction

        {

            PartiallyDownloadedBlock tmp = partialBlock;

            partialBlock.FillBlock(block2, {block.vtx[1]}, /*segwit_active=*/true); // Current implementation doesn't check txn here, but don't require that

            partialBlock = tmp;

        }

        BOOST_CHECK_EQUAL(pool.get(block.vtx[2]->GetHash()).use_count(), SHARED_TX_OFFSET + 2); // +2 because of partialBlock and block2

        bool mutated;

        BOOST_CHECK(block.hashMerkleRoot != BlockMerkleRoot(block2, &mutated));


        CBlock block3;

        PartiallyDownloadedBlock partialBlockCopy = partialBlock;

        BOOST_CHECK(partialBlock.FillBlock(block3, {block.vtx[0]}, /*segwit_active=*/true) == READ_STATUS_OK);

        BOOST_CHECK_EQUAL(block.GetHash().ToString(), block3.GetHash().ToString());

        BOOST_CHECK_EQUAL(block.hashMerkleRoot.ToString(), BlockMerkleRoot(block3, &mutated).ToString());

        BOOST_CHECK(!mutated);


        BOOST_CHECK_EQUAL(pool.get(block.vtx[2]->GetHash()).use_count(), SHARED_TX_OFFSET + 3); // +2 because of partialBlock and block2 and block3


        txhash = block.vtx[2]->GetHash();

        block.vtx.clear();

        block2.vtx.clear();

        block3.vtx.clear();

        BOOST_CHECK_EQUAL(pool.get(txhash).use_count(), SHARED_TX_OFFSET + 1 - 1); // + 1 because of partialBlock; -1 because of block.

    }

    BOOST_CHECK_EQUAL(pool.get(txhash).use_count(), SHARED_TX_OFFSET - 1); // -1 because of block

}


BOOST_AUTO_TEST_CASE(SufficientPreforwardRTTest)

{

    CTxMemPool& pool = *Assert(m_node.mempool);

    TestMemPoolEntryHelper entry;

    auto rand_ctx(FastRandomContext(uint256{42}));

    CBlock block(BuildBlockTestCase(rand_ctx));


    LOCK2(cs_main, pool.cs);

    TryAddToMempool(pool, entry.FromTx(block.vtx[1]));

    BOOST_CHECK_EQUAL(pool.get(block.vtx[1]->GetHash()).use_count(), SHARED_TX_OFFSET + 0);


    Txid txhash;


    // Test with pre-forwarding coinbase + tx 2 with tx 1 in mempool

    {

        TestHeaderAndShortIDs shortIDs(block, rand_ctx);

        shortIDs.prefilledtxn.resize(2);

        shortIDs.prefilledtxn[0] = {0, block.vtx[0]};

        shortIDs.prefilledtxn[1] = {1, block.vtx[2]}; // id == 1 as it is 1 after index 1

        shortIDs.shorttxids.resize(1);

        shortIDs.shorttxids[0] = shortIDs.GetShortID(block.vtx[1]->GetWitnessHash());


        DataStream stream{};

        stream << shortIDs;


        CBlockHeaderAndShortTxIDs shortIDs2;

        stream >> shortIDs2;


        PartiallyDownloadedBlock partialBlock(&pool);

        BOOST_CHECK(partialBlock.InitData(shortIDs2, empty_extra_txn) == READ_STATUS_OK);

        BOOST_CHECK( partialBlock.IsTxAvailable(0));

        BOOST_CHECK( partialBlock.IsTxAvailable(1));

        BOOST_CHECK( partialBlock.IsTxAvailable(2));


        BOOST_CHECK_EQUAL(pool.get(block.vtx[1]->GetHash()).use_count(), SHARED_TX_OFFSET + 1);


        CBlock block2;

        PartiallyDownloadedBlock partialBlockCopy = partialBlock;

        BOOST_CHECK(partialBlock.FillBlock(block2, {}, /*segwit_active=*/true) == READ_STATUS_OK);

        BOOST_CHECK_EQUAL(block.GetHash().ToString(), block2.GetHash().ToString());

        bool mutated;

        BOOST_CHECK_EQUAL(block.hashMerkleRoot.ToString(), BlockMerkleRoot(block2, &mutated).ToString());

        BOOST_CHECK(!mutated);


        txhash = block.vtx[1]->GetHash();

        block.vtx.clear();

        block2.vtx.clear();

        BOOST_CHECK_EQUAL(pool.get(txhash).use_count(), SHARED_TX_OFFSET + 1 - 1); // + 1 because of partialBlock; -1 because of block.

    }

    BOOST_CHECK_EQUAL(pool.get(txhash).use_count(), SHARED_TX_OFFSET - 1); // -1 because of block

}


BOOST_AUTO_TEST_CASE(EmptyBlockRoundTripTest)

{

    CTxMemPool& pool = *Assert(m_node.mempool);

    CMutableTransaction coinbase = BuildTransactionTestCase();


    CBlock block;

    auto rand_ctx(FastRandomContext(uint256{42}));

    block.vtx.resize(1);

    block.vtx[0] = MakeTransactionRef(std::move(coinbase));

    block.nVersion = 42;

    block.hashPrevBlock = rand_ctx.rand256();

    block.nBits = 0x207fffff;


    bool mutated;

    block.hashMerkleRoot = BlockMerkleRoot(block, &mutated);

    assert(!mutated);

    while (!CheckProofOfWork(block.GetHash(), block.nBits, Params().GetConsensus())) ++block.nNonce;


    // Test simple header round-trip with only coinbase

    {

        CBlockHeaderAndShortTxIDs shortIDs{block, rand_ctx.rand64()};


        DataStream stream{};

        stream << shortIDs;


        CBlockHeaderAndShortTxIDs shortIDs2;

        stream >> shortIDs2;


        PartiallyDownloadedBlock partialBlock(&pool);

        BOOST_CHECK(partialBlock.InitData(shortIDs2, empty_extra_txn) == READ_STATUS_OK);

        BOOST_CHECK(partialBlock.IsTxAvailable(0));


        CBlock block2;

        std::vector<CTransactionRef> vtx_missing;

        BOOST_CHECK(partialBlock.FillBlock(block2, vtx_missing, /*segwit_active=*/true) == READ_STATUS_OK);

        BOOST_CHECK_EQUAL(block.GetHash().ToString(), block2.GetHash().ToString());

        BOOST_CHECK_EQUAL(block.hashMerkleRoot.ToString(), BlockMerkleRoot(block2, &mutated).ToString());

        BOOST_CHECK(!mutated);

    }

}


BOOST_AUTO_TEST_CASE(ReceiveWithExtraTransactions) {

    CTxMemPool& pool = *Assert(m_node.mempool);

    TestMemPoolEntryHelper entry;

    auto rand_ctx(FastRandomContext(uint256{42}));


    CMutableTransaction mtx = BuildTransactionTestCase();

    mtx.vin[0].prevout.hash = Txid::FromUint256(rand_ctx.rand256());

    mtx.vin[0].prevout.n = 0;

    const CTransactionRef non_block_tx = MakeTransactionRef(std::move(mtx));


    CBlock block(BuildBlockTestCase(rand_ctx));

    // Leave one transaction missing so scanning doesn't stop before the collision.

    mtx = BuildTransactionTestCase();

    mtx.vin[0].prevout.hash = Txid::FromUint256(rand_ctx.rand256());

    block.vtx.push_back(MakeTransactionRef(std::move(mtx)));

    block.hashMerkleRoot = BlockMerkleRoot(block);

    while (!CheckProofOfWork(block.GetHash(), block.nBits, Params().GetConsensus())) ++block.nNonce;


    std::vector<std::pair<Wtxid, CTransactionRef>> extra_txn;

    extra_txn.resize(10);


    LOCK2(cs_main, pool.cs);

    TryAddToMempool(pool, entry.FromTx(block.vtx[2]));

    BOOST_CHECK_EQUAL(pool.get(block.vtx[2]->GetHash()).use_count(), SHARED_TX_OFFSET + 0);

    // Ensure the non_block_tx is actually not in the block

    for (const auto &block_tx : block.vtx) {

        BOOST_CHECK_NE(block_tx->GetHash(), non_block_tx->GetHash());

    }

    // Ensure block.vtx[1] is not in pool

    BOOST_CHECK_EQUAL(pool.get(block.vtx[1]->GetHash()), nullptr);


    {

        const CBlockHeaderAndShortTxIDs cmpctblock{block, rand_ctx.rand64()};

        PartiallyDownloadedBlock partial_block(&pool);

        PartiallyDownloadedBlock partial_block_with_extra(&pool);


        BOOST_CHECK(partial_block.InitData(cmpctblock, extra_txn) == READ_STATUS_OK);

        BOOST_CHECK( partial_block.IsTxAvailable(0));

        BOOST_CHECK(!partial_block.IsTxAvailable(1));

        BOOST_CHECK( partial_block.IsTxAvailable(2));


        // Add an unrelated tx to extra_txn:

        extra_txn[0] = {non_block_tx->GetWitnessHash(), non_block_tx};

        // and a tx from the block that's not in the mempool:

        extra_txn[1] = {block.vtx[1]->GetWitnessHash(), block.vtx[1]};


        BOOST_CHECK(partial_block_with_extra.InitData(cmpctblock, extra_txn) == READ_STATUS_OK);

        BOOST_CHECK(partial_block_with_extra.IsTxAvailable(0));

        // This transaction is now available via extra_txn:

        BOOST_CHECK(partial_block_with_extra.IsTxAvailable(1));

        BOOST_CHECK(partial_block_with_extra.IsTxAvailable(2));


        // Simulate a mempool collision after finding an unrelated extra transaction.

        extra_txn[2] = {block.vtx[2]->GetWitnessHash(), non_block_tx};

        TestPartiallyDownloadedBlock partial_block_with_extra_collision{&pool};

        BOOST_CHECK_EQUAL(partial_block_with_extra_collision.InitData(cmpctblock, extra_txn), READ_STATUS_OK);

        BOOST_CHECK(partial_block_with_extra_collision.IsTxAvailable(1));

        BOOST_CHECK(!partial_block_with_extra_collision.IsTxAvailable(2));

        BOOST_CHECK_EQUAL(partial_block_with_extra_collision.GetMempoolCount(), 0U);

        BOOST_CHECK_EQUAL(partial_block_with_extra_collision.GetExtraCount(), 1U);


        // Now also collide the extra-sourced slot: both counters decrement exactly once.

        extra_txn[3] = {block.vtx[1]->GetWitnessHash(), non_block_tx};

        TestPartiallyDownloadedBlock partial_block_with_extra_source_collision{&pool};

        BOOST_CHECK_EQUAL(partial_block_with_extra_source_collision.InitData(cmpctblock, extra_txn), READ_STATUS_OK);

        BOOST_CHECK(!partial_block_with_extra_source_collision.IsTxAvailable(1));

        BOOST_CHECK(!partial_block_with_extra_source_collision.IsTxAvailable(2));

        BOOST_CHECK_EQUAL(partial_block_with_extra_source_collision.GetMempoolCount(), 0U);

        BOOST_CHECK_EQUAL(partial_block_with_extra_source_collision.GetExtraCount(), 0U);


        // Collided slots are terminal: not even the genuine transactions refill them.

        extra_txn[4] = {block.vtx[2]->GetWitnessHash(), block.vtx[2]};

        extra_txn[5] = {block.vtx[1]->GetWitnessHash(), block.vtx[1]};

        TestPartiallyDownloadedBlock partial_block_no_refill{&pool};

        BOOST_CHECK_EQUAL(partial_block_no_refill.InitData(cmpctblock, extra_txn), READ_STATUS_OK);

        BOOST_CHECK(!partial_block_no_refill.IsTxAvailable(1));

        BOOST_CHECK(!partial_block_no_refill.IsTxAvailable(2));

        BOOST_CHECK_EQUAL(partial_block_no_refill.GetMempoolCount(), 0U);

        BOOST_CHECK_EQUAL(partial_block_no_refill.GetExtraCount(), 0U);

    }

}


BOOST_AUTO_TEST_CASE(TransactionsRequestSerializationTest) {

    BlockTransactionsRequest req1;

    req1.blockhash = m_rng.rand256();

    req1.indexes.resize(4);

    req1.indexes[0] = 0;

    req1.indexes[1] = 1;

    req1.indexes[2] = 3;

    req1.indexes[3] = 4;


    DataStream stream{};

    stream << req1;


    BlockTransactionsRequest req2;

    stream >> req2;


    BOOST_CHECK_EQUAL(req1.blockhash.ToString(), req2.blockhash.ToString());

    BOOST_CHECK_EQUAL(req1.indexes.size(), req2.indexes.size());

    BOOST_CHECK_EQUAL(req1.indexes[0], req2.indexes[0]);

    BOOST_CHECK_EQUAL(req1.indexes[1], req2.indexes[1]);

    BOOST_CHECK_EQUAL(req1.indexes[2], req2.indexes[2]);

    BOOST_CHECK_EQUAL(req1.indexes[3], req2.indexes[3]);

}


BOOST_AUTO_TEST_CASE(TransactionsRequestDeserializationMaxTest) {

    // Check that the highest legal index is decoded correctly

    BlockTransactionsRequest req0;

    req0.blockhash = m_rng.rand256();

    req0.indexes.resize(1);

    req0.indexes[0] = 0xffff;

    DataStream stream{};

    stream << req0;


    BlockTransactionsRequest req1;

    stream >> req1;

    BOOST_CHECK_EQUAL(req0.indexes.size(), req1.indexes.size());

    BOOST_CHECK_EQUAL(req0.indexes[0], req1.indexes[0]);

}


BOOST_AUTO_TEST_CASE(TransactionsRequestDeserializationOverflowTest) {

    // Any set of index deltas that starts with N values that sum to (0x10000 - N)

    // causes the edge-case overflow that was originally not checked for. Such

    // a request cannot be created by serializing a real BlockTransactionsRequest

    // due to the overflow, so here we'll serialize from raw deltas.

    BlockTransactionsRequest req0;

    req0.blockhash = m_rng.rand256();

    req0.indexes.resize(3);

    req0.indexes[0] = 0x7000;

    req0.indexes[1] = 0x10000 - 0x7000 - 2;

    req0.indexes[2] = 0;

    DataStream stream{};

    stream << req0.blockhash;

    WriteCompactSize(stream, req0.indexes.size());

    WriteCompactSize(stream, req0.indexes[0]);

    WriteCompactSize(stream, req0.indexes[1]);

    WriteCompactSize(stream, req0.indexes[2]);


    BlockTransactionsRequest req1;

    BOOST_CHECK_EXCEPTION(stream >> req1, std::ios_base::failure, HasReason{"differential value overflow"});

}


BOOST_AUTO_TEST_SUITE_END()

TryAddToMempool
TryAddToMempool(pool, CTxMemPoolEntry(tx, fee, 0, 1, 0, false, 4, lp))

m_node
node::NodeContext m_node
Definition bitcoin-gui.cpp:48

blockencodings.h

READ_STATUS_OK
@ READ_STATUS_OK
Definition blockencodings.h:85

READ_STATUS_INVALID
@ READ_STATUS_INVALID
Definition blockencodings.h:86

BuildBlockTestCase
static CBlock BuildBlockTestCase(FastRandomContext &ctx)
Definition blockencodings_tests.cpp:31

BOOST_AUTO_TEST_CASE
BOOST_AUTO_TEST_CASE(SimpleRoundTripTest)
Definition blockencodings_tests.cpp:63

empty_extra_txn
const std::vector< std::pair< Wtxid, CTransactionRef > > empty_extra_txn
Definition blockencodings_tests.cpp:18

SHARED_TX_OFFSET
constexpr long SHARED_TX_OFFSET
Definition blockencodings_tests.cpp:61

BuildTransactionTestCase
static CMutableTransaction BuildTransactionTestCase()
Definition blockencodings_tests.cpp:22

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

Assert
#define Assert(val)
Identity function.
Definition check.h:119

BlockTransactionsRequest
Definition blockencodings.h:45

BlockTransactionsRequest::blockhash
uint256 blockhash
Definition blockencodings.h:48

CBlockHeaderAndShortTxIDs
Definition blockencodings.h:90

CBlockHeaderAndShortTxIDs::GetShortID
uint64_t GetShortID(const Wtxid &wtxid) const
Definition blockencodings.cpp:47

CBlockHeader
Nodes collect new transactions into a block, hash them into a hash tree, and scan through nonce value...
Definition block.h:27

CBlockHeader::nNonce
uint32_t nNonce
Definition block.h:35

CBlockHeader::nBits
uint32_t nBits
Definition block.h:34

CBlockHeader::nVersion
int32_t nVersion
Definition block.h:30

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

CBlockHeader::hashMerkleRoot
uint256 hashMerkleRoot
Definition block.h:32

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

CBlock
Definition block.h:74

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

CTxMemPool
CTxMemPool stores valid-according-to-the-current-best-chain transactions that may be included in the ...
Definition txmempool.h:188

CTxMemPool::removeRecursive
void check(const CCoinsViewCache &active_coins_tip, int64_t spendheight) const EXCLUSIVE_LOCKS_REQUIRED(void removeRecursive(const CTransaction &tx, MemPoolRemovalReason reason) EXCLUSIVE_LOCKS_REQUIRED(cs)
If sanity-checking is turned on, check makes sure the pool is consistent (does not contain two transa...
Definition txmempool.h:324

CTxMemPool::get
CTransactionRef get(const Txid &hash) const
Return a mempool transaction with a given hash.
Definition txmempool.cpp:660

CTxMemPool::size
unsigned long size() const
Definition txmempool.h:496

DataStream
Double ended buffer combining vector and stream-like interfaces.
Definition streams.h:165

FastRandomContext
Fast randomness source.
Definition random.h:386

HasReason
BOOST_CHECK_EXCEPTION predicates to check the specific validation error.
Definition common.h:19

PartiallyDownloadedBlock
Definition blockencodings.h:133

PartiallyDownloadedBlock::PartiallyDownloadedBlock
PartiallyDownloadedBlock(CTxMemPool *poolIn)
Definition blockencodings.h:158

PartiallyDownloadedBlock::extra_count
size_t extra_count
Definition blockencodings.h:139

PartiallyDownloadedBlock::FillBlock
ReadStatus FillBlock(CBlock &block, const std::vector< CTransactionRef > &vtx_missing, bool segwit_active)
Definition blockencodings.cpp:243

PartiallyDownloadedBlock::mempool_count
size_t mempool_count
Definition blockencodings.h:139

PartiallyDownloadedBlock::IsTxAvailable
bool IsTxAvailable(size_t index) const
Definition blockencodings.cpp:235

PartiallyDownloadedBlock::InitData
ReadStatus InitData(const CBlockHeaderAndShortTxIDs &cmpctblock, const std::vector< std::pair< Wtxid, CTransactionRef > > &extra_txn)
Definition blockencodings.cpp:60

RandomMixin::rand256
uint256 rand256() noexcept
generate a random uint256.
Definition random.h:317

TestHeaderAndShortIDs
Definition blockencodings_tests.cpp:120

TestHeaderAndShortIDs::TestHeaderAndShortIDs
TestHeaderAndShortIDs(const CBlockHeaderAndShortTxIDs &orig)
Definition blockencodings_tests.cpp:128

TestHeaderAndShortIDs::shorttxids
std::vector< uint64_t > shorttxids
Definition blockencodings_tests.cpp:125

TestHeaderAndShortIDs::nonce
uint64_t nonce
Definition blockencodings_tests.cpp:124

TestHeaderAndShortIDs::prefilledtxn
std::vector< PrefilledTransaction > prefilledtxn
Definition blockencodings_tests.cpp:126

TestHeaderAndShortIDs::TestHeaderAndShortIDs
TestHeaderAndShortIDs(const CBlock &block, FastRandomContext &ctx)
Definition blockencodings_tests.cpp:133

TestHeaderAndShortIDs::GetShortID
uint64_t GetShortID(const Wtxid &txhash) const
Definition blockencodings_tests.cpp:136

TestHeaderAndShortIDs::SERIALIZE_METHODS
SERIALIZE_METHODS(TestHeaderAndShortIDs, obj)
Definition blockencodings_tests.cpp:144

TestHeaderAndShortIDs::header
CBlockHeader header
Definition blockencodings_tests.cpp:123

base_blob::ToString
std::string ToString() const
Definition uint256.cpp:21

transaction_identifier< true >

transaction_identifier< false >::FromUint256
static transaction_identifier FromUint256(const uint256 &id)
Definition transaction_identifier.h:38

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

BlockMerkleRoot
uint256 BlockMerkleRoot(const CBlock &block, bool *mutated)
Definition merkle.cpp:76

cs_main
RecursiveMutex cs_main
Mutex to guard access to validation specific variables, such as reading or changing the chainstate.
Definition cs_main.cpp:8

BOOST_FIXTURE_TEST_SUITE
BOOST_FIXTURE_TEST_SUITE(cuckoocache_tests, BasicTestingSetup)
Test Suite for CuckooCache.

BOOST_AUTO_TEST_SUITE_END
BOOST_AUTO_TEST_SUITE_END()

BOOST_CHECK_EXCEPTION
BOOST_CHECK_EXCEPTION(HTTPHeaders{}.Read(reader), std::runtime_error, HasReason{"Empty HTTP header name"})

MemPoolRemovalReason::REPLACED
@ REPLACED
Removed for replacement.

merkle.h

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

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

CheckProofOfWork
bool CheckProofOfWork(uint256 hash, unsigned int nBits, const Consensus::Params &params)
Check whether a block hash satisfies the proof-of-work requirement specified by nBits.
Definition pow.cpp:140

pow.h

MakeTransactionRef
static CTransactionRef MakeTransactionRef(Tx &&txIn)
Definition transaction.h:418

CTransactionRef
std::shared_ptr< const CTransaction > CTransactionRef
Definition transaction.h:417

WriteCompactSize
void WriteCompactSize(SizeComputer &os, uint64_t nSize)
Definition serialize.h:1151

Using
static Wrapper< Formatter, T & > Using(T &&t)
Cause serialization/deserialization of an object to be done using a specified formatter class.
Definition serialize.h:491

READWRITE
#define READWRITE(...)
Definition serialize.h:148

setup_common.h

streams.h

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

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

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

CustomUintFormatter
Serialization wrapper class for custom integers and enums.
Definition serialize.h:525

RegTestingSetup
Identical to TestingSetup, but chain set to regtest.
Definition setup_common.h:126

TestMemPoolEntryHelper
Definition txmempool.h:19

TestMemPoolEntryHelper::FromTx
CTxMemPoolEntry FromTx(const CMutableTransaction &tx) const
Definition txmempool.cpp:34

TestPartiallyDownloadedBlock
Definition blockencodings_tests.cpp:147

TestPartiallyDownloadedBlock::GetExtraCount
size_t GetExtraCount() const
Definition blockencodings_tests.cpp:151

TestPartiallyDownloadedBlock::GetMempoolCount
size_t GetMempoolCount() const
Definition blockencodings_tests.cpp:150

VectorFormatter
Formatter to serialize/deserialize vector elements using another formatter.
Definition serialize.h:667

node::NodeContext::mempool
std::unique_ptr< CTxMemPool > mempool
Definition context.h:69

LOCK2
#define LOCK2(cs1, cs2)
Definition sync.h:269

common.h

random.h

txmempool.h

BOOST_CHECK_NE
BOOST_CHECK_NE(OneL.ToString(), ArrayToString(ZeroArray, 32))

Ticks
constexpr auto Ticks(Dur2 d)
Helper to count the seconds of a duration/time_point.
Definition time.h:82

assert
assert(!tx.IsCoinBase())