immutableblockheader/immutableblock

Author: pstratem

src/primitives/block.cpp

@@ -8,11 +8,25 @@
 #include <hash.h>
 #include <tinyformat.h>
 
+CBlockHeader::CBlockHeader(const ImmutableBlockHeader &header) :
+    nVersion(header.nVersion),
+    hashPrevBlock(header.hashPrevBlock),
+    hashMerkleRoot(header.hashMerkleRoot),
+    nTime(header.nTime),
+    nBits(header.nBits),
+    nNonce(header.nNonce)
+{}
+
 uint256 CBlockHeader::GetHash() const
 {
     return (HashWriter{} << *this).GetHash();
 }
 
+CBlock::CBlock(const ImmutableBlock &block) :
+    CBlockHeader(block),
+    vtx(block.vtx)
+{}
+
 std::string CBlock::ToString() const
 {
     std::stringstream s;
@@ -28,3 +42,34 @@ std::string CBlock::ToString() const
     }
     return s.str();
 }
+
+ImmutableBlockHeader::ImmutableBlockHeader(const CBlockHeader& header) :
+    nVersion(header.nVersion),
+    hashPrevBlock(header.hashPrevBlock),
+    hashMerkleRoot(header.hashMerkleRoot),
+    nTime(header.nTime),
+    nBits(header.nBits),
+    nNonce(header.nNonce)
+{}
+
+ImmutableBlock::ImmutableBlock(const CBlock& block) :
+    ImmutableBlockHeader(block),
+    vtx(block.vtx)
+{
+}
+
+std::string ImmutableBlock::ToString() const
+{
+    std::stringstream s;
+    s << strprintf("CBlock(hash=%s, ver=0x%08x, hashPrevBlock=%s, hashMerkleRoot=%s, nTime=%u, nBits=%08x, nNonce=%u, vtx=%u)\n",
+        GetHash().ToString(),
+        nVersion,
+        hashPrevBlock.ToString(),
+        hashMerkleRoot.ToString(),
+        nTime, nBits, nNonce,
+        vtx.size());
+    for (const auto& tx : vtx) {
+        s << "  " << tx->ToString() << "\n";
+    }
+    return s.str();
+}

src/primitives/block.h

@@ -6,6 +6,12 @@
 #ifndef BITCOIN_PRIMITIVES_BLOCK_H
 #define BITCOIN_PRIMITIVES_BLOCK_H
 
+class CBlockHeader;
+class CBlock;
+class ImmutableBlockHeader;
+class ImmutableBlock;
+
+#include <consensus/merkle.h>
 #include <primitives/transaction.h>
 #include <serialize.h>
 #include <uint256.h>
@@ -34,6 +40,8 @@ class CBlockHeader
         SetNull();
     }
 
+    CBlockHeader(const ImmutableBlockHeader &header);
+
     SERIALIZE_METHODS(CBlockHeader, obj) { READWRITE(obj.nVersion, obj.hashPrevBlock, obj.hashMerkleRoot, obj.nTime, obj.nBits, obj.nNonce); }
 
     void SetNull()
@@ -64,6 +72,66 @@ class CBlockHeader
     }
 };
 
+class ImmutableBlockHeader
+{
+public:
+    const int32_t nVersion;
+    const uint256 hashPrevBlock;
+    const uint256 hashMerkleRoot;
+    const uint32_t nTime;
+    const uint32_t nBits;
+    const uint32_t nNonce;
+private:
+    mutable std::optional<uint256> hash;
+public:
+    /** Convert a CBlockHeader into a ImmutableBlockHeader. */
+    explicit ImmutableBlockHeader(const CBlockHeader& header);
+
+    uint256 GetHash() const
+    {
+        if (!hash.has_value())
+            hash = CBlockHeader(*this).GetHash();
+        return *hash;
+    }
+
+    NodeSeconds Time() const
+    {
+        return NodeSeconds{std::chrono::seconds{nTime}};
+    }
+
+    int64_t GetBlockTime() const
+    {
+        return (int64_t)nTime;
+    }
+};
+
+class ImmutableBlock : public ImmutableBlockHeader
+{
+public:
+    const std::vector<CTransactionRef> vtx;
+
+    // Memory-only flags for caching expensive checks
+    mutable bool fChecked;                            // CheckBlock()
+    mutable bool m_checked_witness_commitment{false}; // CheckWitnessCommitment()
+    mutable bool m_checked_merkle_root{false};        // CheckMerkleRoot()
+
+    explicit ImmutableBlock(const CBlock& block);
+    explicit ImmutableBlock(CBlock&& block);
+
+    CBlockHeader GetBlockHeader() const
+    {
+        CBlockHeader block;
+        block.nVersion       = nVersion;
+        block.hashPrevBlock  = hashPrevBlock;
+        block.hashMerkleRoot = hashMerkleRoot;
+        block.nTime          = nTime;
+        block.nBits          = nBits;
+        block.nNonce         = nNonce;
+        return block;
+    }
+
+    std::string ToString() const;
+};
 
 class CBlock : public CBlockHeader
 {
@@ -81,6 +149,8 @@ class CBlock : public CBlockHeader
         SetNull();
     }
 
+    CBlock(const ImmutableBlock &block);
+
     CBlock(const CBlockHeader &header)
     {
         SetNull();