Adjust and activate post-merge pre-capella proofs for block headers (#3118)

Only activated post-merge proofs pre capella/shanghai.

Author: kdeme

fluffy/eth_data/yaml_eth_types.nim

@@ -1,5 +1,5 @@
 # fluffy
-# Copyright (c) 2024 Status Research & Development GmbH
+# Copyright (c) 2024-2025 Status Research & Development GmbH
 # Licensed and distributed under either of
 #   * MIT license (license terms in the root directory or at https://opensource.org/licenses/MIT).
 #   * Apache v2 license (license terms in the root directory or at https://www.apache.org/licenses/LICENSE-2.0).
@@ -12,16 +12,16 @@ import ssz_serialization/types, stew/byteutils
 type
   YamlTestProofBellatrix* = object
     execution_block_header*: string # Not part of the actual proof
-    beacon_block_proof*: array[11, string]
+    execution_block_proof*: array[11, string]
     beacon_block_root*: string
-    historical_roots_proof*: array[14, string]
+    beacon_block_proof*: array[14, string]
     slot*: uint64
 
   YamlTestProof* = object
     execution_block_header*: string # Not part of the actual proof
-    beacon_block_proof*: array[11, string]
+    execution_block_proof*: array[11, string]
     beacon_block_root*: string
-    historical_summaries_proof*: array[13, string]
+    beacon_block_proof*: array[13, string]
     slot*: uint64
 
 proc fromHex*[n](T: type array[n, Digest], a: array[n, string]): T =

fluffy/network/history/content/content_values.nim

@@ -30,8 +30,6 @@ const
 
 type
   ## BlockHeader types
-  HistoricalHashesAccumulatorProof* = array[15, Digest]
-
   BlockHeaderWithProof* = object
     header*: ByteList[MAX_HEADER_LENGTH] # RLP data
     proof*: ByteList[MAX_HEADER_PROOF_LENGTH]

fluffy/network/history/history_network.nim

@@ -14,6 +14,7 @@ import
   eth/trie/ordered_trie,
   eth/common/[hashes, headers_rlp, blocks_rlp, receipts_rlp, transactions_rlp],
   eth/p2p/discoveryv5/[protocol, enr],
+  beacon_chain/spec/presets,
   ../../common/common_types,
   ../../database/content_db,
   ../../network_metadata,
@@ -27,7 +28,7 @@ from eth/common/accounts import EMPTY_ROOT_HASH
 logScope:
   topics = "portal_hist"
 
-export blocks_rlp
+export blocks_rlp, presets
 
 const pingExtensionCapabilities = {CapabilitiesType, HistoryRadiusType}
 
@@ -36,8 +37,8 @@ type
     portalProtocol*: PortalProtocol
     contentDB*: ContentDB
     contentQueue*: AsyncQueue[(Opt[NodeId], ContentKeysList, seq[seq[byte]])]
-    accumulator*: FinishedHistoricalHashesAccumulator
-    historicalRoots*: HistoricalRoots
+    cfg*: RuntimeConfig
+    accumulators*: HistoryAccumulators
     processContentLoop: Future[void]
     statusLogLoop: Future[void]
     contentRequestRetries: int
@@ -146,7 +147,9 @@ proc getVerifiedBlockHeader*(
         debug "Failed fetching block header with proof from the network"
         return Opt.none(Header)
 
-      header = validateCanonicalHeaderBytes(headerContent.content, id, n.accumulator).valueOr:
+      header = validateCanonicalHeaderBytes(
+        headerContent.content, id, n.accumulators, n.cfg
+      ).valueOr:
         n.portalProtocol.banNode(
           headerContent.receivedFrom.id, NodeBanDurationContentLookupFailedValidation
         )
@@ -304,7 +307,7 @@ proc validateContent(
   case contentKey.contentType
   of blockHeader:
     let _ = validateCanonicalHeaderBytes(
-      content, contentKey.blockHeaderKey.blockHash, n.accumulator
+      content, contentKey.blockHeaderKey.blockHash, n.accumulators, n.cfg
     ).valueOr:
       return err("Failed validating block header: " & error)
 
@@ -327,7 +330,7 @@ proc validateContent(
     ok()
   of blockNumber:
     let _ = validateCanonicalHeaderBytes(
-      content, contentKey.blockNumberKey.blockNumber, n.accumulator
+      content, contentKey.blockNumberKey.blockNumber, n.accumulators, n.cfg
     ).valueOr:
       return err("Failed validating block header: " & error)
 
@@ -341,7 +344,8 @@ proc new*(
     baseProtocol: protocol.Protocol,
     contentDB: ContentDB,
     streamManager: StreamManager,
-    accumulator: FinishedHistoricalHashesAccumulator,
+    cfg: RuntimeConfig,
+    accumulator: FinishedHistoricalHashesAccumulator = loadAccumulator(),
     historicalRoots: HistoricalRoots = loadHistoricalRoots(),
     bootstrapRecords: openArray[Record] = [],
     portalConfig: PortalProtocolConfig = defaultPortalProtocolConfig,
@@ -370,8 +374,10 @@ proc new*(
     portalProtocol: portalProtocol,
     contentDB: contentDB,
     contentQueue: contentQueue,
-    accumulator: accumulator,
-    historicalRoots: historicalRoots,
+    cfg: cfg,
+    accumulators: HistoryAccumulators(
+      historicalHashes: accumulator, historicalRoots: historicalRoots
+    ),
     contentRequestRetries: contentRequestRetries,
   )
 
@@ -432,7 +438,8 @@ proc statusLogLoop(n: HistoryNetwork) {.async: (raises: []).} =
 proc start*(n: HistoryNetwork) =
   info "Starting Portal execution history network",
     protocolId = n.portalProtocol.protocolId,
-    accumulatorRoot = hash_tree_root(n.accumulator)
+    historicalHashesAccumulatorRoot = hash_tree_root(n.accumulators.historicalHashes),
+    historiricalRootsRoot = hash_tree_root(n.accumulators.historicalRoots)
 
   n.portalProtocol.start()
 

fluffy/network/history/history_validation.nim

@@ -10,14 +10,23 @@
 import
   chronos/timer,
   eth/trie/ordered_trie,
+  beacon_chain/spec/presets,
   ../../network_metadata,
   ./history_type_conversions,
-  ./validation/historical_hashes_accumulator
+  ./validation/[
+    historical_hashes_accumulator, block_proof_historical_roots,
+    block_proof_historical_summaries,
+  ]
 
 from eth/common/eth_types_rlp import rlpHash
 
 export historical_hashes_accumulator
 
+type HistoryAccumulators* = object
+  historicalHashes*: FinishedHistoricalHashesAccumulator
+  historicalRoots*: HistoricalRoots
+  historicalSummaries*: HistoricalSummaries
+
 func validateHeader(header: Header, blockHash: Hash32): Result[void, string] =
   if not (header.rlpHash() == blockHash):
     err("Header hash does not match")
@@ -50,32 +59,57 @@ func validateHeaderBytes*(
   ok(header)
 
 func verifyBlockHeaderProof*(
-    a: FinishedHistoricalHashesAccumulator,
+    a: HistoryAccumulators,
     header: Header,
     proof: ByteList[MAX_HEADER_PROOF_LENGTH],
+    cfg: RuntimeConfig,
 ): Result[void, string] =
   let timestamp = Moment.init(header.timestamp.int64, Second)
 
   if isShanghai(chainConfig, timestamp):
-    # TODO: Add verification post merge based on historical_summaries
-    err("Shanghai block verification not implemented")
+    # Note: currently disabled
+    # - No effective means to get historical summaries yet over the network
+    # - Proof is currently not as per spec, as we prefer to use SSZ Vectors
+
+    # let proof = decodeSsz(proof.asSeq(), BlockProofHistoricalSummaries).valueOr:
+    #   return err("Failed decoding historical_summaries based block proof: " & error)
+
+    # if a.historicalSummaries.verifyProof(
+    #   proof, Digest(data: header.rlpHash().data), cfg
+    # ):
+    #   ok()
+    # else:
+    #   err("Block proof verification failed (historical_summaries)")
+    err("Shanghai block proof verification not yet activated")
   elif isPoSBlock(chainConfig, header.number):
-    # TODO: Add verification post merge based on historical_roots
-    err("PoS block verification not implemented")
+    let proof = decodeSsz(proof.asSeq(), BlockProofHistoricalRoots).valueOr:
+      return err("Failed decoding historical_roots based block proof: " & error)
+
+    if a.historicalRoots.verifyProof(proof, Digest(data: header.rlpHash().data)):
+      ok()
+    else:
+      err("Block proof verification failed (historical roots)")
   else:
     let accumulatorProof = decodeSsz(proof.asSeq(), HistoricalHashesAccumulatorProof).valueOr:
-      return err("Failed decoding accumulator proof: " & error)
+      return
+        err("Failed decoding historical hashes accumulator based block proof: " & error)
 
-    a.verifyAccumulatorProof(header, accumulatorProof)
+    if a.historicalHashes.verifyProof(header, accumulatorProof):
+      ok()
+    else:
+      err("Block proof verification failed (historical hashes accumulator)")
 
 func validateCanonicalHeaderBytes*(
-    bytes: openArray[byte], id: uint64 | Hash32, a: FinishedHistoricalHashesAccumulator
+    bytes: openArray[byte],
+    id: uint64 | Hash32,
+    accumulators: HistoryAccumulators,
+    cfg: RuntimeConfig,
 ): Result[Header, string] =
   let headerWithProof = decodeSsz(bytes, BlockHeaderWithProof).valueOr:
     return err("Failed decoding header with proof: " & error)
   let header = ?validateHeaderBytes(headerWithProof.header.asSeq(), id)
 
-  ?a.verifyBlockHeaderProof(header, headerWithProof.proof)
+  ?accumulators.verifyBlockHeaderProof(header, headerWithProof.proof, cfg)
 
   ok(header)
 

fluffy/network/history/validation/block_proof_historical_roots.nim

@@ -1,5 +1,5 @@
 # Fluffy
-# Copyright (c) 2022-2024 Status Research & Development GmbH
+# Copyright (c) 2022-2025 Status Research & Development GmbH
 # Licensed and distributed under either of
 #   * MIT license (license terms in the root directory or at https://opensource.org/licenses/MIT).
 #   * Apache v2 license (license terms in the root directory or at https://www.apache.org/licenses/LICENSE-2.0).
@@ -78,10 +78,12 @@ import
   ssz_serialization,
   ssz_serialization/[proofs, merkleization],
   beacon_chain/spec/eth2_ssz_serialization,
+  beacon_chain/spec/ssz_codec,
   beacon_chain/spec/datatypes/bellatrix,
+  beacon_chain/spec/forks,
   ./block_proof_common
 
-export block_proof_common
+export block_proof_common, ssz_codec
 
 type
   BeaconBlockProofHistoricalRoots* = array[14, Digest]
@@ -93,6 +95,8 @@ type
     executionBlockProof*: ExecutionBlockProof
     slot*: Slot
 
+  HistoricalRoots* = HashList[Digest, Limit HISTORICAL_ROOTS_LIMIT]
+
 func getHistoricalRootsIndex*(slot: Slot): uint64 =
   slot div SLOTS_PER_HISTORICAL_ROOT
 
@@ -149,7 +153,7 @@ func verifyProof*(
   verify_merkle_multiproof(@[blockHeaderRoot], proof, @[gIndex], historicalRoot)
 
 func verifyProof*(
-    historical_roots: HashList[Eth2Digest, Limit HISTORICAL_ROOTS_LIMIT],
+    historical_roots: HistoricalRoots,
     proof: BlockProofHistoricalRoots,
     blockHash: Digest,
 ): bool =

fluffy/network/history/validation/block_proof_historical_summaries.nim

@@ -1,5 +1,5 @@
 # Fluffy
-# Copyright (c) 2023-2024 Status Research & Development GmbH
+# Copyright (c) 2023-2025 Status Research & Development GmbH
 # Licensed and distributed under either of
 #   * MIT license (license terms in the root directory or at https://opensource.org/licenses/MIT).
 #   * Apache v2 license (license terms in the root directory or at https://www.apache.org/licenses/LICENSE-2.0).
@@ -28,11 +28,12 @@ import
   ssz_serialization,
   ssz_serialization/[proofs, merkleization],
   beacon_chain/spec/eth2_ssz_serialization,
-  beacon_chain/spec/presets,
+  beacon_chain/spec/ssz_codec,
   beacon_chain/spec/datatypes/capella,
+  beacon_chain/spec/forks,
   ./block_proof_common
 
-export block_proof_common
+export block_proof_common, ssz_codec
 
 type
   BeaconBlockProofHistoricalRoots* = array[13, Digest]
@@ -44,6 +45,8 @@ type
     executionBlockProof*: ExecutionBlockProof
     slot*: Slot
 
+  HistoricalSummaries* = HashList[HistoricalSummary, Limit HISTORICAL_ROOTS_LIMIT]
+
 template `[]`(x: openArray[Eth2Digest], chunk: Limit): Eth2Digest =
   # Nim 2.0 requires arrays to be indexed by the same type they're declared with.
   # Both HistoricalBatch.block_roots and HistoricalBatch.state_roots
@@ -104,7 +107,7 @@ func verifyProof*(
   verify_merkle_multiproof(@[blockHeaderRoot], proof, @[gIndex], historicalRoot)
 
 func verifyProof*(
-    historical_summaries: HashList[HistoricalSummary, Limit HISTORICAL_ROOTS_LIMIT],
+    historical_summaries: HistoricalSummaries,
     proof: BlockProofHistoricalSummaries,
     blockHash: Digest,
     cfg: RuntimeConfig,

fluffy/network/history/validation/historical_hashes_accumulator.nim

@@ -69,6 +69,8 @@ type
     historicalEpochs*: List[Bytes32, int(MAX_HISTORICAL_EPOCHS)]
     currentEpoch*: EpochRecord
 
+  HistoricalHashesAccumulatorProof* = array[15, Digest]
+
   Bytes32 = common_types.Bytes32
 
 func init*(T: type HistoricalHashesAccumulator): T =
@@ -146,8 +148,10 @@ func isPreMerge*(blockNumber: uint64): bool =
 func isPreMerge*(header: Header): bool =
   isPreMerge(header.number)
 
-func verifyProof(
-    a: FinishedHistoricalHashesAccumulator, header: Header, proof: openArray[Digest]
+func verifyProof*(
+    a: FinishedHistoricalHashesAccumulator,
+    header: Header,
+    proof: HistoricalHashesAccumulatorProof,
 ): bool =
   let
     epochIndex = getEpochIndex(header)
@@ -160,21 +164,6 @@ func verifyProof(
 
   verify_merkle_multiproof(@[leave], proof, @[gIndex], epochRecordHash)
 
-func verifyAccumulatorProof*(
-    a: FinishedHistoricalHashesAccumulator,
-    header: Header,
-    proof: HistoricalHashesAccumulatorProof,
-): Result[void, string] =
-  if header.isPreMerge():
-    # Note: The proof is typed with correct depth, so no check on this is
-    # required here.
-    if a.verifyProof(header, proof):
-      ok()
-    else:
-      err("Proof verification failed")
-  else:
-    err("Cannot verify post merge header with accumulator proof")
-
 func buildProof*(
     header: Header, epochRecord: EpochRecord | EpochRecordCached
 ): Result[HistoricalHashesAccumulatorProof, string] =

fluffy/portal_node.nim

@@ -1,5 +1,5 @@
 # Fluffy
-# Copyright (c) 2024 Status Research & Development GmbH
+# Copyright (c) 2024-2025 Status Research & Development GmbH
 # Licensed and distributed under either of
 #   * MIT license (license terms in the root directory or at https://opensource.org/licenses/MIT).
 #   * Apache v2 license (license terms in the root directory or at https://www.apache.org/licenses/LICENSE-2.0).
@@ -137,6 +137,7 @@ proc new*(
             discovery,
             contentDB,
             streamManager,
+            networkData.metadata.cfg,
             accumulator,
             bootstrapRecords = bootstrapRecords,
             portalConfig = config.portalConfig,

fluffy/tests/history_network_tests/test_block_proof_historical_roots_vectors.nim

@@ -1,5 +1,5 @@
 # Fluffy
-# Copyright (c) 2024 Status Research & Development GmbH
+# Copyright (c) 2024-2025 Status Research & Development GmbH
 # Licensed and distributed under either of
 #   * MIT license (license terms in the root directory or at https://opensource.org/licenses/MIT).
 #   * Apache v2 license (license terms in the root directory or at https://www.apache.org/licenses/LICENSE-2.0).
@@ -33,10 +33,10 @@ suite "History Block Proofs - Historical Roots - Test Vectors":
 
           blockHash = Digest.fromHex(testProof.execution_block_header)
           blockProof = BlockProofHistoricalRoots(
-            beaconBlockProof:
-              array[14, Digest].fromHex(testProof.historical_roots_proof),
+            beaconBlockProof: array[14, Digest].fromHex(testProof.beacon_block_proof),
             beaconBlockRoot: Digest.fromHex(testProof.beacon_block_root),
-            executionBlockProof: array[11, Digest].fromHex(testProof.beacon_block_proof),
+            executionBlockProof:
+              array[11, Digest].fromHex(testProof.execution_block_proof),
             slot: Slot(testProof.slot),
           )
 

fluffy/tests/history_network_tests/test_block_proof_historical_summaries.nim

@@ -1,5 +1,5 @@
 # Nimbus
-# Copyright (c) 2022-2024 Status Research & Development GmbH
+# Copyright (c) 2022-2025 Status Research & Development GmbH
 # Licensed and distributed under either of
 #   * MIT license (license terms in the root directory or at https://opensource.org/licenses/MIT).
 #   * Apache v2 license (license terms in the root directory or at https://www.apache.org/licenses/LICENSE-2.0).
@@ -112,7 +112,7 @@ suite "History Block Proofs - Historical Summaries":
     for i in blocksToTest:
       let beaconBlock = blocks[i].message
 
-      let res = buildProof(beaconBlock)
+      let res = block_proof_historical_summaries.buildProof(beaconBlock)
       check res.isOk()
       let proof = res.get()