Merge branch 'master' into eip4444-wip

advaita-saha · web-flow · commit 32d9bfced4c1 · 2025-03-09T10:49:03.000+05:30
diff --git a/fluffy/network/history/history_validation.nim b/fluffy/network/history/history_validation.nim
@@ -66,11 +66,21 @@ func verifyBlockHeaderProof*(
 ): Result[void, string] =
   let timestamp = Moment.init(header.timestamp.int64, Second)
 
-  if isShanghai(chainConfig, timestamp):
-    # 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
+  # Note: Capella onwards 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
+  if isCancun(chainConfig, timestamp):
+    # let proof = decodeSsz(proof.asSeq(), BlockProofHistoricalSummariesDeneb).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("Cancun block proof verification not yet activated")
+  elif isShanghai(chainConfig, timestamp):
     # let proof = decodeSsz(proof.asSeq(), BlockProofHistoricalSummaries).valueOr:
     #   return err("Failed decoding historical_summaries based block proof: " & error)
 
diff --git a/fluffy/network/history/validation/block_proof_common.nim b/fluffy/network/history/validation/block_proof_common.nim
@@ -1,15 +1,36 @@
 # 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).
 # at your option. This file may not be copied, modified, or distributed except according to those terms.
 
 {.push raises: [].}
 
-import results, beacon_chain/spec/presets, beacon_chain/spec/forks
+import results, stew/bitops2, beacon_chain/spec/presets, beacon_chain/spec/forks
 
-type ExecutionBlockProof* = array[11, Digest]
+const
+  # BeaconBlock level:
+  # - 8 as there are 5 fields
+  # - 4 as index (pos) of field is 4
+  gIndexTopLevel = (1 * 1 * 8 + 4)
+  # BeaconBlockBody level:
+  # - 16 as there are 10 fields
+  # - 9 as index (pos) of field is 9
+  gIndexMidLevel = (gIndexTopLevel * 1 * 16 + 9)
+  # ExecutionPayload level:
+  # - 16 as there are 14 fields
+  # - 12 as pos of field is 12
+  EXECUTION_BLOCK_HASH_GINDEX* = GeneralizedIndex(gIndexMidLevel * 1 * 16 + 12)
+  # ExecutionPayload Deneb level:
+  # - 32 as there are 17 fields
+  # - 12 as pos of field is 12
+  EXECUTION_BLOCK_HASH_GINDEX_DENEB* = GeneralizedIndex(gIndexMidLevel * 1 * 32 + 12)
+
+type
+  ExecutionBlockProof* = array[log2trunc(EXECUTION_BLOCK_HASH_GINDEX), Digest]
+  ExecutionBlockProofDeneb* =
+    array[log2trunc(EXECUTION_BLOCK_HASH_GINDEX_DENEB), Digest]
 
 func getBlockRootsIndex*(slot: Slot): uint64 =
   slot mod SLOTS_PER_HISTORICAL_ROOT
@@ -20,33 +41,35 @@ func getBlockRootsIndex*(beaconBlock: SomeForkyBeaconBlock): uint64 =
 # Builds proof to be able to verify that the EL block hash is part of the
 # CL BeaconBlock for given root.
 func buildProof*(
-    beaconBlock: SomeForkyBeaconBlock
+    beaconBlock:
+      bellatrix.TrustedBeaconBlock | bellatrix.BeaconBlock | capella.TrustedBeaconBlock |
+      capella.BeaconBlock
 ): Result[ExecutionBlockProof, string] =
-  let
-    # BeaconBlock level:
-    # - 8 as there are 5 fields
-    # - 4 as index (pos) of field is 4
-    gIndexTopLevel = (1 * 1 * 8 + 4)
-    # BeaconBlockBody level:
-    # - 16 as there are 10 fields
-    # - 9 as index (pos) of field is 9
-    gIndexMidLevel = (gIndexTopLevel * 1 * 16 + 9)
-    # ExecutionPayload level:
-    # - 16 as there are 14 fields
-    # - 12 as pos of field is 12
-    gIndex = GeneralizedIndex(gIndexMidLevel * 1 * 16 + 12)
-
   var proof: ExecutionBlockProof
-  ?beaconBlock.build_proof(gIndex, proof)
+  ?beaconBlock.build_proof(EXECUTION_BLOCK_HASH_GINDEX, proof)
+
+  ok(proof)
+
+func buildProof*(
+    beaconBlock:
+      deneb.TrustedBeaconBlock | deneb.BeaconBlock | electra.TrustedBeaconBlock |
+      electra.BeaconBlock
+): Result[ExecutionBlockProofDeneb, string] =
+  var proof: ExecutionBlockProofDeneb
+  ?beaconBlock.build_proof(EXECUTION_BLOCK_HASH_GINDEX_DENEB, proof)
 
   ok(proof)
 
 func verifyProof*(
     blockHash: Digest, proof: ExecutionBlockProof, blockRoot: Digest
 ): bool =
-  let
-    gIndexTopLevel = (1 * 1 * 8 + 4)
-    gIndexMidLevel = (gIndexTopLevel * 1 * 16 + 9)
-    gIndex = GeneralizedIndex(gIndexMidLevel * 1 * 16 + 12)
+  verify_merkle_multiproof(
+    @[blockHash], proof, @[EXECUTION_BLOCK_HASH_GINDEX], blockRoot
+  )
 
-  verify_merkle_multiproof(@[blockHash], proof, @[gIndex], blockRoot)
+func verifyProof*(
+    blockHash: Digest, proof: ExecutionBlockProofDeneb, blockRoot: Digest
+): bool =
+  verify_merkle_multiproof(
+    @[blockHash], proof, @[EXECUTION_BLOCK_HASH_GINDEX_DENEB], blockRoot
+  )
diff --git a/fluffy/network/history/validation/block_proof_historical_roots.nim b/fluffy/network/history/validation/block_proof_historical_roots.nim
@@ -89,7 +89,7 @@ type
   BeaconBlockProofHistoricalRoots* = array[14, Digest]
 
   BlockProofHistoricalRoots* = object
-    # Total size (11 + 1 + 14) * 32 bytes + 4 bytes = 836 bytes
+    # Total size (14 + 1 + 11) * 32 bytes + 4 bytes = 836 bytes
     beaconBlockProof*: BeaconBlockProofHistoricalRoots
     beaconBlockRoot*: Digest
     executionBlockProof*: ExecutionBlockProof
diff --git a/fluffy/network/history/validation/block_proof_historical_summaries.nim b/fluffy/network/history/validation/block_proof_historical_summaries.nim
@@ -36,15 +36,22 @@ import
 export block_proof_common, ssz_codec
 
 type
-  BeaconBlockProofHistoricalRoots* = array[13, Digest]
+  BeaconBlockProofHistoricalSummaries* = array[13, Digest]
 
   BlockProofHistoricalSummaries* = object
-    # Total size (11 + 1 + 13) * 32 bytes + 4 bytes = 804 bytes
-    beaconBlockProof*: BeaconBlockProofHistoricalRoots
+    # Total size (13 + 1 + 11) * 32 bytes + 4 bytes = 804 bytes
+    beaconBlockProof*: BeaconBlockProofHistoricalSummaries
     beaconBlockRoot*: Digest
     executionBlockProof*: ExecutionBlockProof
     slot*: Slot
 
+  BlockProofHistoricalSummariesDeneb* = object
+    # Total size (13 + 1 + 12) * 32 bytes + 4 bytes = 836 bytes
+    beaconBlockProof*: BeaconBlockProofHistoricalSummaries
+    beaconBlockRoot*: Digest
+    executionBlockProof*: ExecutionBlockProofDeneb
+    slot*: Slot
+
   HistoricalSummaries* = HashList[HistoricalSummary, Limit HISTORICAL_ROOTS_LIMIT]
 
 template `[]`(x: openArray[Eth2Digest], chunk: Limit): Eth2Digest =
@@ -67,11 +74,11 @@ func getHistoricalSummariesIndex*(
 # block_roots for given root.
 func buildProof*(
     blockRoots: array[SLOTS_PER_HISTORICAL_ROOT, Eth2Digest], blockRootIndex: uint64
-): Result[BeaconBlockProofHistoricalRoots, string] =
+): Result[BeaconBlockProofHistoricalSummaries, string] =
   # max list size * 1 is start point of leaves
   let gIndex = GeneralizedIndex(SLOTS_PER_HISTORICAL_ROOT + blockRootIndex)
 
-  var proof: BeaconBlockProofHistoricalRoots
+  var proof: BeaconBlockProofHistoricalSummaries
   ?blockRoots.build_proof(gIndex, proof)
 
   ok(proof)
@@ -96,9 +103,29 @@ func buildProof*(
     )
   )
 
+func buildProof*(
+    blockRoots: array[SLOTS_PER_HISTORICAL_ROOT, Eth2Digest],
+    beaconBlock:
+      deneb.TrustedBeaconBlock | deneb.BeaconBlock | electra.TrustedBeaconBlock |
+      electra.BeaconBlock,
+): Result[BlockProofHistoricalSummariesDeneb, string] =
+  let
+    blockRootIndex = getBlockRootsIndex(beaconBlock)
+    executionBlockProof = ?beaconBlock.buildProof()
+    beaconBlockProof = ?blockRoots.buildProof(blockRootIndex)
+
+  ok(
+    BlockProofHistoricalSummariesDeneb(
+      beaconBlockRoot: hash_tree_root(beaconBlock),
+      beaconBlockProof: beaconBlockProof,
+      executionBlockProof: executionBlockProof,
+      slot: beaconBlock.slot,
+    )
+  )
+
 func verifyProof*(
     blockHeaderRoot: Digest,
-    proof: BeaconBlockProofHistoricalRoots,
+    proof: BeaconBlockProofHistoricalSummaries,
     historicalRoot: Digest,
     blockRootIndex: uint64,
 ): bool =
@@ -108,7 +135,7 @@ func verifyProof*(
 
 func verifyProof*(
     historical_summaries: HistoricalSummaries,
-    proof: BlockProofHistoricalSummaries,
+    proof: BlockProofHistoricalSummaries | BlockProofHistoricalSummariesDeneb,
     blockHash: Digest,
     cfg: RuntimeConfig,
 ): bool =
diff --git a/fluffy/network_metadata.nim b/fluffy/network_metadata.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).
@@ -73,6 +73,7 @@ type
     mergeNetsplitBlock*: uint64
     shanghaiTime*: Opt[Moment]
     cancunTime*: Opt[Moment]
+    pragueTime*: Opt[Moment]
 
 const
   # Allow this to be adjusted at compile time for testing. If more constants
@@ -82,8 +83,9 @@ const
 
   chainConfig* = ChainConfig(
     mergeNetsplitBlock: mergeBlockNumber,
-    shanghaiTime: Opt.some(Moment.init(1681338455'i64, Second)),
-    cancunTime: Opt.none(Moment),
+    shanghaiTime: Opt.some(Moment.init(1_681_338_455'i64, Second)),
+    cancunTime: Opt.some(Moment.init(1_710_338_135'i64, Second)),
+    pragueTime: Opt.some(Moment.init(1_740_434_112'i64, Second)),
   )
 
 func isTimestampForked(forkTime: Opt[Moment], timestamp: Moment): bool =
@@ -100,3 +102,6 @@ func isShanghai*(c: ChainConfig, timestamp: Moment): bool =
 
 func isCancun*(c: ChainConfig, timestamp: Moment): bool =
   isTimestampForked(c.cancunTime, timestamp)
+
+func isPrague*(c: ChainConfig, timestamp: Moment): bool =
+  isTimestampForked(c.pragueTime, timestamp)
diff --git a/fluffy/tests/history_network_tests/all_history_network_tests.nim b/fluffy/tests/history_network_tests/all_history_network_tests.nim
@@ -1,5 +1,5 @@
 # Nimbus
-# Copyright (c) 2024 Status Research & Development GmbH
+# Copyright (c) 2024-2025 Status Research & Development GmbH
 # Licensed under either of
 #  * Apache License, version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
 #  * MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
@@ -15,4 +15,5 @@ import
   ./test_block_proof_historical_roots,
   ./test_block_proof_historical_roots_vectors,
   ./test_block_proof_historical_summaries,
+  ./test_block_proof_historical_summaries_deneb,
   ./test_block_proof_historical_summaries_vectors
diff --git a/fluffy/tests/history_network_tests/test_block_proof_historical_summaries.nim b/fluffy/tests/history_network_tests/test_block_proof_historical_summaries.nim
@@ -69,7 +69,7 @@ suite "History Block Proofs - Historical Summaries":
 
   # One more slot to hit second SLOTS_PER_HISTORICAL_ROOT, hitting first
   # historical_summary.
-  blocks.add(addTestBlock(state[], cache, cfg = cfg).capellaData)
+  discard addTestBlock(state[], cache, cfg = cfg)
 
   # Starts from the block after genesis.
   const blocksToTest = [
diff --git a/fluffy/tests/history_network_tests/test_block_proof_historical_summaries_deneb.nim b/fluffy/tests/history_network_tests/test_block_proof_historical_summaries_deneb.nim
@@ -0,0 +1,119 @@
+# Nimbus
+# Copyright (c) 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).
+# at your option. This file may not be copied, modified, or distributed except according to those terms.
+
+{.used.}
+
+{.push raises: [].}
+
+import
+  unittest2,
+  beacon_chain/spec/forks,
+  beacon_chain/spec/datatypes/deneb,
+  beacon_chain /../ tests/testblockutil,
+  # Mock helpers
+  beacon_chain /../ tests/mocking/mock_genesis,
+  ../../network/history/validation/block_proof_historical_summaries
+
+suite "History Block Proofs - Historical Summaries - Deneb":
+  let
+    cfg = block:
+      var res = defaultRuntimeConfig
+      res.ALTAIR_FORK_EPOCH = GENESIS_EPOCH
+      res.BELLATRIX_FORK_EPOCH = GENESIS_EPOCH
+      res.CAPELLA_FORK_EPOCH = GENESIS_EPOCH
+      res.DENEB_FORK_EPOCH = GENESIS_EPOCH
+      res
+    state = newClone(initGenesisState(cfg = cfg))
+  var cache = StateCache()
+
+  var blocks: seq[deneb.SignedBeaconBlock]
+
+  # Note:
+  # Adding 8192*2 blocks. First block is genesis block and not one of these.
+  # Then one extra block is needed to get the historical roots, block
+  # roots and state roots processed.
+  # index i = 0 is second block.
+  # index i = 8190 is 8192th block and last one that is part of the first
+  # historical root
+
+  # genesis + 8191 slots, next one will be capella fork
+  for i in 0 ..< SLOTS_PER_HISTORICAL_ROOT - 1:
+    blocks.add(addTestBlock(state[], cache, cfg = cfg).denebData)
+
+  # One more slot to hit second SLOTS_PER_HISTORICAL_ROOT, hitting first
+  # historical_summary.
+  discard addTestBlock(state[], cache, cfg = cfg)
+
+  # Starts from the block after genesis.
+  const blocksToTest = [
+    0'u64,
+    1,
+    2,
+    3,
+    SLOTS_PER_HISTORICAL_ROOT div 2,
+    SLOTS_PER_HISTORICAL_ROOT - 3,
+    SLOTS_PER_HISTORICAL_ROOT - 2,
+  ]
+
+  test "BeaconBlockProofHistoricalSummaries for BeaconBlock":
+    let blockRoots = getStateField(state[], block_roots).data
+
+    withState(state[]):
+      when consensusFork >= ConsensusFork.Capella:
+        let historical_summaries = forkyState.data.historical_summaries
+
+        # for i in 0..<(SLOTS_PER_HISTORICAL_ROOT - 1): # Test all blocks
+        for i in blocksToTest:
+          let
+            beaconBlock = blocks[i].message
+            historicalRootsIndex = getHistoricalSummariesIndex(beaconBlock.slot, cfg)
+            blockRootIndex = getBlockRootsIndex(beaconBlock.slot)
+
+          let res = buildProof(blockRoots, blockRootIndex)
+          check res.isOk()
+          let proof = res.get()
+
+          check verifyProof(
+            blocks[i].root,
+            proof,
+            historical_summaries[historicalRootsIndex].block_summary_root,
+            blockRootIndex,
+          )
+
+  test "ExecutionBlockProof for Execution BlockHeader":
+    # for i in 0..<(SLOTS_PER_HISTORICAL_ROOT - 1): # Test all blocks
+    for i in blocksToTest:
+      let beaconBlock = blocks[i].message
+
+      let res = block_proof_historical_summaries.buildProof(beaconBlock)
+      check res.isOk()
+      let proof = res.get()
+
+      let leave = beaconBlock.body.execution_payload.block_hash
+      check verifyProof(leave, proof, blocks[i].root)
+
+  test "BlockProofHistoricalSummaries for Execution BlockHeader":
+    let blockRoots = getStateField(state[], block_roots).data
+
+    withState(state[]):
+      when consensusFork >= ConsensusFork.Capella:
+        let historical_summaries = forkyState.data.historical_summaries
+
+        # for i in 0..<(SLOTS_PER_HISTORICAL_ROOT - 1): # Test all blocks
+        for i in blocksToTest:
+          let
+            beaconBlock = blocks[i].message
+            # Normally we would have an execution BlockHeader that holds this
+            # value, but we skip the creation of that header for now and just take
+            # the blockHash from the execution payload.
+            blockHash = beaconBlock.body.execution_payload.block_hash
+
+          let proofRes = buildProof(blockRoots, beaconBlock)
+          check proofRes.isOk()
+          let proof = proofRes.get()
+
+          check verifyProof(historical_summaries, proof, blockHash, cfg)
