WIP: Add Prague support

retesteth/configs/clientconfigs/t8ntool.cpp

@@ -105,7 +105,8 @@ string const t8ntool_config = R"({
         "London",
         "Paris",
         "Shanghai",
-        "Cancun"
+        "Cancun",
+        "Prague"
     ],
     "additionalForks" : [
         "FrontierToHomesteadAt5",
@@ -119,8 +120,7 @@ string const t8ntool_config = R"({
         "GrayGlacier",
         "ParisToShanghaiAtTime15k",
         "ShanghaiToCancunAtTime15k",
-        "Merge",
-        "Prague"
+        "Merge"
     ],
     "fillerSkipForks" : [
     ],

retesteth/session/ToolBackend/Verification.cpp

@@ -146,6 +146,13 @@ void verify4844Block(spBlockHeader const& _header, ToolChain const& _chain)
     }
 }
 
+void verifyPragueBlock(spBlockHeader const& _header, ToolChain const& _chain)
+{
+    (void)_chain;
+    check_blockType(_header->type(), BlockType::BlockHeaderPrague, "verifyPragueBlock");
+    verifyCommonParisRules(_header, "Prague");
+}
+
 void verifyParisBlock(spBlockHeader const& _header, ToolChain const& _chain)
 {
     (void)_chain;
@@ -243,6 +250,13 @@ void verify4844Parent(spBlockHeader const& _header, spBlockHeader const& _parent
     }
 }
 
+void verifyPragueParent(spBlockHeader const& _header, spBlockHeader const& _parent, ToolChain const& _chain)
+{
+    check_blockType(_header->type(), BlockType::BlockHeaderPrague, "verifyPragueParent");
+    if (_parent->type() == BlockType::BlockHeaderPrague)
+        verifyPragueBlock(_parent, _chain);
+}
+
 void verifyParisParent(spBlockHeader const& _header, spBlockHeader const& _parent, ToolChain const& _chain, VALUE const& _parentTD)
 {
     /// Verify the rules
@@ -348,6 +362,9 @@ void verifyBlockParent(spBlockHeader const& _header, ToolChain const& _chain)
             case BlockType::BlockHeader4844:
                 verify4844Parent(_header, parentBlock.header(), _chain);
                 break;
+            case BlockType::BlockHeaderPrague:
+                verifyPragueParent(_header, parentBlock.header(), _chain);
+                break;
             default:
                 throw test::UpwardsException("[retesteth]: verifyBlockParent::Unhandled block type check!");
             }
@@ -384,6 +401,9 @@ void verifyEthereumBlockHeader(spBlockHeader const& _header, ToolChain const& _c
     case BlockType::BlockHeader4844:
         verify4844Block(_header, _chain);
         break;
+    case BlockType::BlockHeaderPrague:
+        verifyPragueBlock(_header, _chain);
+        break;
     default:
         throw test::UpwardsException("[retesteth]: verifyEthereumBlockHeader::Unhandled block type check!");
     }

retesteth/testStructures/PrepareChainParams.cpp

@@ -72,7 +72,6 @@ spDataObject prepareGenesisSubsection(StateTestEnvBase const& _env, ParamsContex
             }
         }
     }
-
     if (!cfg.cfgFile().support1559())
     {
         (*genesis).removeKey(c_baseFeePerGas);
@@ -106,6 +105,11 @@ spDataObject prepareGenesisSubsection(StateTestEnvBase const& _env, ParamsContex
         _genesis[c_currentBeaconRoot] = _env.currentBeaconRoot().asString();
     };
 
+    auto pragfy = [&_env, &cancunfy](DataObject& _genesis){
+        cancunfy(_genesis);
+        _genesis[c_currentBeaconRoot] = _env.currentBeaconRoot().asString();
+    };
+
     if (!netIsAdditional)
     {
         bool knowLondon = cfg.checkForkInProgression("London");
@@ -123,6 +127,12 @@ spDataObject prepareGenesisSubsection(StateTestEnvBase const& _env, ParamsContex
         bool knowCancun = cfg.checkForkInProgression("Cancun");
         if (knowCancun && compareFork(net, CMP::ge, FORK("Cancun")))
             cancunfy(genesis.getContent());
+
+        bool knowPrague = cfg.checkForkInProgression("Prague");
+        if (knowPrague && compareFork(net, CMP::ge, FORK("Prague")))
+        {
+            pragfy(genesis.getContent());
+        }
     }
     else
     {

retesteth/testStructures/types/Ethereum/Blocks/BlockHeader.cpp

@@ -18,6 +18,7 @@ std::string BlockHeader::BlockTypeToString(BlockType _bl)
         case BlockType::BlockHeaderParis: return "BlockHeaderParis";
         case BlockType::BlockHeaderShanghai: return "BlockHeaderShanghai";
         case BlockType::BlockHeader4844: return "BlockHeader4844";
+        case BlockType::BlockHeaderPrague: return "BlockHeaderPrague";
         default: return "UnparsedBlockType";
     };
     return "UnparsedBlockType";

retesteth/testStructures/types/Ethereum/Blocks/BlockHeader.h

@@ -11,7 +11,8 @@ enum class BlockType
     BlockHeader1559,
     BlockHeaderParis,
     BlockHeaderShanghai,
-    BlockHeader4844
+    BlockHeader4844,
+    BlockHeaderPrague
 };
 
 // Ethereum blockheader interface

retesteth/testStructures/types/Ethereum/Blocks/BlockHeader1559.cpp

@@ -98,7 +98,8 @@ inline bool isChild(BlockType _t)
     return _t != BlockType::BlockHeader1559 &&
            _t != BlockType::BlockHeaderParis &&
            _t != BlockType::BlockHeaderShanghai &&
-           _t != BlockType::BlockHeader4844;
+           _t != BlockType::BlockHeader4844 &&
+           _t != BlockType::BlockHeaderPrague;
 }
 }
 

retesteth/testStructures/types/Ethereum/Blocks/BlockHeader4844.cpp

@@ -112,7 +112,8 @@ namespace  {
 inline bool isChild(BlockType _t)
 {
     // Can't use compareFork function here because of EthereumClassic and custom fork names
-    return _t != BlockType::BlockHeader4844;
+    return _t != BlockType::BlockHeader4844 &&
+           _t != BlockType::BlockHeaderPrague;
 }
 }
 

retesteth/testStructures/types/Ethereum/Blocks/BlockHeaderParis.cpp

@@ -13,7 +13,8 @@ inline bool isChild(BlockType _t)
     // Can't use compareFork function here because of EthereumClassic and custom fork names
     return _t != BlockType::BlockHeaderParis &&
            _t != BlockType::BlockHeaderShanghai &&
-           _t != BlockType::BlockHeader4844;
+           _t != BlockType::BlockHeader4844 &&
+           _t != BlockType::BlockHeaderPrague;
 }
 }
 

retesteth/testStructures/types/Ethereum/Blocks/BlockHeaderPrague.cpp

@@ -0,0 +1,124 @@
+#include "BlockHeaderPrague.h"
+#include <libdevcore/Address.h> 
+#include <retesteth/helpers/TestHelper.h>
+#include <retesteth/EthChecks.h>
+#include <retesteth/testStructures/Common.h>
+#include <retesteth/Constants.h>
+
+using namespace std;
+using namespace dev;
+using namespace test::debug;
+using namespace test::teststruct::constnames;
+
+namespace test::teststruct
+{
+
+void BlockHeaderPrague::checkDataScheme(DataObject const& _data) const
+{
+    // Allowed fields for this structure
+    REQUIRE_JSONFIELDS(_data, "BlockHeaderPrague " + _data.getKey(),
+        {
+            {c_bloom, {{DataType::String}, jsonField::Optional}},
+            {c_logsBloom, {{DataType::String}, jsonField::Optional}},
+            {c_coinbase, {{DataType::String}, jsonField::Optional}},
+            {c_author, {{DataType::String}, jsonField::Optional}},
+            {c_miner, {{DataType::String}, jsonField::Optional}},
+            {c_difficulty, {{DataType::String}, jsonField::Required}},
+            {c_extraData, {{DataType::String}, jsonField::Required}},
+            {c_gasLimit, {{DataType::String}, jsonField::Required}},
+            {c_baseFeePerGas, {{DataType::String}, jsonField::Required}},
+            {c_gasUsed, {{DataType::String}, jsonField::Required}},
+            {c_hash, {{DataType::String}, jsonField::Optional}},
+            {c_mixHash, {{DataType::String}, jsonField::Optional}},
+            {c_nonce, {{DataType::String}, jsonField::Optional}},
+            {c_number, {{DataType::String}, jsonField::Required}},
+            {c_parentHash, {{DataType::String}, jsonField::Required}},
+            {c_receiptTrie, {{DataType::String}, jsonField::Optional}},
+            {c_receiptsRoot, {{DataType::String}, jsonField::Optional}},
+            {c_stateRoot, {{DataType::String}, jsonField::Required}},
+            {c_timestamp, {{DataType::String}, jsonField::Required}},
+            {c_transactionsTrie, {{DataType::String}, jsonField::Optional}},
+            {c_transactionsRoot, {{DataType::String}, jsonField::Optional}},
+            {c_sha3Uncles, {{DataType::String}, jsonField::Optional}},
+            {c_uncleHash, {{DataType::String}, jsonField::Optional}},
+            {c_withdrawalsRoot, {{DataType::String}, jsonField::Required}},
+            {c_blobGasUsed, {{DataType::String}, jsonField::Required}},
+            {c_excessBlobGas, {{DataType::String}, jsonField::Required}},
+            {c_parentBeaconBlockRoot, {{DataType::String}, jsonField::Required}},
+            {"rejectedTransactions", {{DataType::Array}, jsonField::Optional}},   // EthGetBlockBy test debug field
+            {"seedHash", {{DataType::String}, jsonField::Optional}},         // EthGetBlockBy aleth field
+            {"boundary", {{DataType::String}, jsonField::Optional}},         // EthGetBlockBy aleth field
+            {"size", {{DataType::String}, jsonField::Optional}},             // EthGetBlockBy field
+            {"totalDifficulty", {{DataType::String}, jsonField::Optional}},  // EthGetBlockBy field
+            {"transactions", {{DataType::Array}, jsonField::Optional}},      // EthGetBlockBy field
+            {"uncles", {{DataType::Array}, jsonField::Optional}},            // EthGetBlockBy field
+            {"withdrawals", {{DataType::Array}, jsonField::Optional}}        // EthGetBlockBy field
+        });
+}
+
+void BlockHeaderPrague::_fromData(DataObject const& _data)
+{
+    BlockHeader4844::_fromData(_data);
+}
+
+size_t BlockHeaderPrague::_fromRLP(dev::RLP const& _rlp)
+{
+   return BlockHeader4844::_fromRLP(_rlp);
+}
+
+BlockHeaderPrague::BlockHeaderPrague(dev::RLP const& _rlp)
+{
+    _fromRLP(_rlp);
+    recalculateHash();
+}
+
+spDataObject BlockHeaderPrague::asDataObject() const
+{
+    spDataObject out = BlockHeader4844::asDataObject();
+    return out;
+}
+
+const RLPStream BlockHeaderPrague::asRLPStream() const
+{
+    return BlockHeader4844::asRLPStream();
+}
+
+namespace {
+inline bool isChild(BlockType _t)
+{
+    return _t != BlockType::BlockHeaderPrague;
+}
+} // namespace
+
+BlockHeaderPrague& BlockHeaderPrague::castFrom(BlockHeader& _from)
+{
+    try
+    {
+        if (isChild(_from.type()))
+            ETH_FAIL_MESSAGE("BlockHeaderPrague::castFrom() got wrong block type!");
+        return dynamic_cast<BlockHeaderPrague&>(_from);
+    }
+    catch (...)
+    {
+        ETH_FAIL_MESSAGE("BlockHeaderPrague::castFrom() failed!");
+    }
+    return dynamic_cast<BlockHeaderPrague&>(_from);
+}
+
+BlockHeaderPrague const& BlockHeaderPrague::castFrom(spBlockHeader const& _from)
+{
+    try
+    {
+        if (isChild(_from->type()))
+            ETH_FAIL_MESSAGE("BlockHeaderPrague::castFrom() got wrong block type!");
+        return dynamic_cast<BlockHeaderPrague const&>(_from.getCContent());
+    }
+    catch (...)
+    {
+        ETH_FAIL_MESSAGE("BlockHeaderPrague::castFrom() failed!");
+    }
+    spBlockHeaderPrague foo(new BlockHeaderPrague(DataObject()));
+    return foo.getCContent();
+}
+
+}  // namespace teststruct

retesteth/testStructures/types/Ethereum/Blocks/BlockHeaderPrague.h

@@ -0,0 +1,30 @@
+#pragma once
+#include <retesteth/testStructures/basetypes.h>
+#include "BlockHeader4844.h"
+#include <libdevcore/RLP.h>
+#include <libdataobj/DataObject.h>
+
+namespace test::teststruct
+{
+struct BlockHeaderPrague : BlockHeader4844
+{
+    BlockHeaderPrague(DataObject const& _in) { fromData(_in); }
+    BlockHeaderPrague(dev::RLP const& _in);
+
+    virtual spDataObject asDataObject() const override;
+    virtual dev::RLPStream const asRLPStream() const override;
+    virtual BlockType type() const override { return BlockType::BlockHeaderPrague; }
+
+    static BlockHeaderPrague const& castFrom(spBlockHeader const& _from);
+    static BlockHeaderPrague& castFrom(BlockHeader& _from);
+
+protected:
+    virtual void checkDataScheme(DataObject const&) const override;
+    virtual void _fromData(DataObject const&) override;
+    virtual size_t _fromRLP(dev::RLP const&) override;
+
+    BlockHeaderPrague(){};
+};
+
+typedef GCP_SPointer<BlockHeaderPrague> spBlockHeaderPrague;
+}  // namespace teststruct

retesteth/testStructures/types/Ethereum/Blocks/BlockHeaderReader.cpp

@@ -18,6 +18,12 @@ bool isHeader4844(DataObject const& _filledData)
     return false;
 }
 
+bool isHeaderPrague(DataObject const& _filledData)
+{
+  return isHeader4844(_filledData);
+}
+
+
 bool isHeaderShanghai(DataObject const& _filledData)
 {
     if (_filledData.count(c_withdrawalsRoot) && !_filledData.count(c_excessBlobGas))
@@ -70,6 +76,11 @@ bool isHeader4844(dev::RLP const& _rlp)
     return (_rlp.itemCount() == 20);
 }
 
+bool isHeaderPrague(dev::RLP const& _rlp)
+{
+    return isHeader4844(_rlp);
+}
+
 
 bool isHeaderParis(dev::RLP const& _rlp)
 {
@@ -127,6 +138,9 @@ spBlockHeader readBlockHeader(dev::RLP const& _rlp)
     if (isHeader4844(_rlp))
         return spBlockHeader(new BlockHeader4844(_rlp));
 
+    if (isHeaderPrague(_rlp))
+        return spBlockHeader(new BlockHeaderPrague(_rlp));
+
     throw test::UpwardsException("readBlockHeader(RLP): unknown block type! \n" + dev::asString(_rlp.toBytes()));
 }
 
@@ -147,6 +161,9 @@ spBlockHeader readBlockHeader(DataObject const& _filledData)
     if (isHeader4844(_filledData))
         return spBlockHeader(new BlockHeader4844(_filledData));
 
+    if (isHeaderPrague(_filledData))
+        return spBlockHeader(new BlockHeaderPrague(_filledData));
+
     ETH_ERROR_MESSAGE("readBlockHeader(DATA): unknown block type! \n" + _filledData.asJson());
     return spBlockHeader(new BlockHeaderLegacy(_filledData));
 }
@@ -160,26 +177,30 @@ bool isBlockExportCurrentRandom(BlockHeader const& _header)
 {
     return _header.type() == BlockType::BlockHeaderParis
            || _header.type() == BlockType::BlockHeaderShanghai
-           || _header.type() == BlockType::BlockHeader4844;
+           || _header.type() == BlockType::BlockHeader4844
+           || _header.type() == BlockType::BlockHeaderPrague;
 }
 
 bool isBlockExportExcessBlobGas(BlockHeader const& _header)
 {
-    return _header.type() == BlockType::BlockHeader4844;
+    return _header.type() == BlockType::BlockHeader4844
+           || _header.type() == BlockType::BlockHeaderPrague;
 }
 
 bool isBlockExportWithdrawals(BlockHeader const& _header)
 {
     return _header.type() == BlockType::BlockHeaderShanghai
-           || _header.type() == BlockType::BlockHeader4844;
+           || _header.type() == BlockType::BlockHeader4844
+           || _header.type() == BlockType::BlockHeaderPrague;
 }
 
 bool isBlockExportBasefee(BlockHeader const& _header)
 {
     return _header.type() == BlockType::BlockHeader1559
            || _header.type() == BlockType::BlockHeaderParis
            || _header.type() == BlockType::BlockHeaderShanghai
-           || _header.type() == BlockType::BlockHeader4844;
+           || _header.type() == BlockType::BlockHeader4844
+           || _header.type() == BlockType::BlockHeaderPrague;
 }
 
 bool isBlockExportDifficulty(BlockHeader const& _header)

retesteth/testStructures/types/Ethereum/Blocks/BlockHeaderReader.h

@@ -4,6 +4,7 @@
 #include "BlockHeaderParis.h"
 #include "BlockHeaderShanghai.h"
 #include "BlockHeader4844.h"
+#include "BlockHeaderPrague.h"
 
 namespace test::teststruct
 {