use updated get_ptc iterator

Author: Tomi-3-0

.github/workflows/ci.yml

@@ -259,51 +259,11 @@ jobs:
       - name: Check exception tracking
         if: ${{ !cancelled() }} && github.event_name == 'pull_request'
         run: |
-          problematic_files=()
-          while read -r file; do
-            if ! grep -qE '^{\.push raises: \[\](, gcsafe)?\.}$' "$file"; then
-              problematic_files+=("$file")
-            fi
-          done < <(git diff --name-only --diff-filter=AM --ignore-submodules HEAD^ HEAD | grep -E '\.nim$' || true)
-
-          if (( ${#problematic_files[@]} )); then
-            echo "The following files do not have '{.push raises: [], gcsafe.}' (gcsafe optional):"
-            for file in "${problematic_files[@]}"; do
-              echo "- $file"
-            done
-            echo "See https://status-im.github.io/nim-style-guide/errors.exceptions.html"
-            exit 2
-          fi
-
+          scripts/check_exception_headers.sh
       - name: Check submodules
         if: ${{ !cancelled() }} && github.event_name == 'pull_request'
         run: |
-          while read -r file; do
-            commit="$(git -C "$file" rev-parse HEAD)"
-            commit_date=$(TZ=UTC0 git -C "$file" show -s --format='%cd' --date=iso-local HEAD)
-            if ! branch="$(git config -f .gitmodules --get "submodule.$file.branch")"; then
-              echo "Submodule '$file': '.gitmodules' lacks 'branch' entry"
-              exit 2
-            fi
-            # Without the `--depth=1` fetch, may run into 'error processing shallow info: 4'
-            if ! error="$(git -C "$file" fetch -q --depth=1 origin "+refs/heads/${branch}:refs/remotes/origin/${branch}")"; then
-              echo "Submodule '$file': Failed to fetch '$branch': $error (1)"
-              exit 2
-            fi
-            branch_commit_date=$(TZ=UTC0 git -C "$file" show -s --format='%cd' --date=iso-local "refs/remotes/origin/${branch}")
-            if [[ "${commit_date}" > "${branch_commit_date}" ]]; then
-              echo "Submodule '$file': '$commit' ($commit_date) is more recent than latest '$branch' ($branch_commit_date) (branch config: '.gitmodules')"
-              exit 2
-            fi
-            if ! error="$(git -C "$file" fetch -q --shallow-since="$commit_date" origin "+refs/heads/${branch}:refs/remotes/origin/${branch}")"; then
-              echo "Submodule '$file': Failed to fetch '$branch': $error (2)"
-              exit 2
-            fi
-            if ! git -C "$file" merge-base --is-ancestor "$commit" "refs/remotes/origin/$branch"; then
-              echo "Submodule '$file': '$commit' is not on '$branch' as of $commit_date (branch config: '.gitmodules')"
-              exit 2
-            fi
-          done < <(git diff --name-only --diff-filter=AM HEAD^ HEAD | grep -f <(git config --file .gitmodules --get-regexp path | awk '{ print $2 }') || true)
+          scripts/check_submodule_branches.sh
 
   # https://github.com/EnricoMi/publish-unit-test-result-action
   event_file:

AllTests-mainnet.md

@@ -172,6 +172,18 @@ AllTests-mainnet
 ```
 ## ColumnQuarantine data structure test suite  [Preset: mainnet]
 ```diff
++ ColumnQuarantine: update(empty:grow) [node->node] test                                     OK
++ ColumnQuarantine: update(empty:grow) [node->supernode] test                                OK
++ ColumnQuarantine: update(empty:shrink) [node->node] test                                   OK
++ ColumnQuarantine: update(empty:shrink) [supernode->node] test                              OK
++ ColumnQuarantine: update(memory+disk:grow) [node->node] test                               OK
++ ColumnQuarantine: update(memory+disk:grow) [node->supernode] test                          OK
++ ColumnQuarantine: update(memory+disk:shrink) [node->node] test                             OK
++ ColumnQuarantine: update(memory+disk:shrink) [supernode->node] test                        OK
++ ColumnQuarantine: update(memory:grow) [node->node] test                                    OK
++ ColumnQuarantine: update(memory:grow) [node->supernode] test                               OK
++ ColumnQuarantine: update(memory:shrink) [node->node] test                                  OK
++ ColumnQuarantine: update(memory:shrink) [supernode->node] test                             OK
 + Empty in-memory scenario test [node]                                                       OK
 + Empty in-memory scenario test [supernode]                                                  OK
 + Mixed entries scenario test [node]                                                         OK
@@ -1163,9 +1175,11 @@ AllTests-mainnet
 ```
 ## subnet tracker
 ```diff
++ should register and prune PTC duties                                                       OK
 + should register stability subnets on attester duties                                       OK
 + should register sync committee duties                                                      OK
 + should subscribe to all subnets when flag is enabled                                       OK
++ should track PTC duties in slot bitmaps                                                    OK
 ```
 ## test_fixture_ssz_generic_types.nim
 ```diff

CHANGELOG.md

@@ -1,3 +1,27 @@
+2025-11-28 v25.11.1
+===================
+
+The Nimbus consensus client `v25.11.1` is a `high-urgency` release for mainnet due to the impending Fusaka fork and a `medium-urgency` release on other networks due to stability fixes. To access blobs in Fusaka and later in this release, use the `--light-supernode` option. The undocumented `--debug-peerdas-supernode` option will be removed in a pending release.
+
+### Improvements
+
+- Introduce light supernodes to provide blobs with less resource usage:
+  https://github.com/status-im/nimbus-eth2/pull/7752
+
+- Allow the consensus light client to specify finalized block hashes to sync:
+  https://github.com/status-im/nimbus-eth2/pull/7735
+
+- Allow updating column custody during any slot:
+  https://github.com/status-im/nimbus-eth2/pull/7724
+
+### Fixes
+
+- Fix blob and column quarantine-related hang:
+  https://github.com/status-im/nimbus-eth2/pull/7743
+
+- Fix blocking of command-line-supplied invalid blocks:
+  https://github.com/status-im/nimbus-eth2/pull/7714
+
 2025-11-03 v25.11.0
 ===================
 

Makefile

@@ -720,6 +720,7 @@ test_libnimbus_lc: libnimbus_lc.a
 				--std=c17 -flto \
 				-pedantic -pedantic-errors \
 				-Wall -Wextra -Werror -Wno-maybe-uninitialized \
+				-Wno-stringop-overflow \
 				-Wno-unsafe-buffer-usage -Wno-unknown-warning-option \
 				-o build/test_libnimbus_lc \
 				beacon_chain/libnimbus_lc/test_libnimbus_lc.c \

beacon_chain/conf.nim

@@ -251,6 +251,11 @@ type
       desc: "Subscribe to all column subnets, thereby becoming a PeerDAS supernode"
       name: "peerdas-supernode" .}: bool
 
+    lightSupernode* {.
+      defaultValue: false,
+      desc: "Subscribe to the first half of column subnets"
+      name: "light-supernode" .}: bool
+
     slashingDbKind* {.
       hidden
       defaultValue: SlashingDbKind.v2

beacon_chain/consensus_object_pools/blob_quarantine.nim

@@ -82,6 +82,9 @@ type
   ColumnQuarantine* =
     SidecarQuarantine[fulu.DataColumnSidecar, OnDataColumnSidecarCallback]
 
+  ColumnQuarantineNode* =
+    DoublyLinkedNode[RootTableRecord[fulu.DataColumnSidecar]]
+
 func indexLog*[T: SomeSidecarRef](sidecars: openArray[ref T]): string =
   "[" & sidecars.mapIt($uint64(it[].index)).join(",") & "]"
 
@@ -886,12 +889,13 @@ proc init*(
     onDataColumnSidecarCallback: OnDataColumnSidecarCallback
 ): ColumnQuarantine =
   doAssert(len(custodyColumns) <= NUMBER_OF_COLUMNS)
+
+  let custodyMap = ColumnMap.init(custodyColumns)
   var indexMap = newSeqUninit[int](NUMBER_OF_COLUMNS)
   if len(custodyColumns) < NUMBER_OF_COLUMNS:
     for i in 0 ..< len(indexMap):
       indexMap[i] = -1
-  for index, item in custodyColumns.pairs():
-    doAssert(item < uint64(NUMBER_OF_COLUMNS))
+  for index, item in custodyMap.pairs():
     indexMap[int(item)] = index
 
   let size = maxSidecars(NUMBER_OF_COLUMNS)
@@ -911,27 +915,84 @@ proc init*(
     memSidecarsCount: 0,
     diskSidecarsCount: 0,
     indexMap: indexMap,
-    custodyColumns: @custodyColumns,
-    custodyMap: ColumnMap.init(custodyColumns),
+    custodyColumns: toSeq(custodyMap.items),
+    custodyMap: custodyMap,
     list: initDoublyLinkedList[RootTableRecord[fulu.DataColumnSidecar]](),
     db: database,
     onSidecarCallback: onDataColumnSidecarCallback
   )
 
-func updateColumnQuarantine*(
-    quarantine: ref ColumnQuarantine,
+proc update*(
+    quarantine: var ColumnQuarantine,
     cfg: RuntimeConfig,
-    custodyColumns: openArray[ColumnIndex]) =
+    custodyColumns: openArray[ColumnIndex]
+) =
   doAssert(len(custodyColumns) <= NUMBER_OF_COLUMNS)
+  let
+    custodyMap = ColumnMap.init(custodyColumns)
+    maxSidecarsPerBlockCount = len(custodyMap)
+
   var indexMap = newSeqUninit[int](NUMBER_OF_COLUMNS)
   if len(custodyColumns) < NUMBER_OF_COLUMNS:
     for i in 0 ..< len(indexMap):
       indexMap[i] = -1
-  for index, item in custodyColumns.pairs():
-    doAssert(item < uint64(NUMBER_OF_COLUMNS))
+  for index, item in custodyMap.pairs():
     indexMap[int(item)] = index
 
-  quarantine.maxSidecarsPerBlockCount = len(custodyColumns)
+  var
+    memSidecarsCount = 0
+    diskSidecarsCount = 0
+    nodesToRemove: seq[ColumnQuarantineNode]
+
+  for node in quarantine.list.nodes():
+    var
+      sidecars =
+        newSeq[SidecarHolder[fulu.DataColumnSidecar]](len(custodyMap))
+      count = 0
+      unloaded = 0
+
+    for cindex in quarantine.custodyMap.items():
+      let
+        index = quarantine.getIndex(cindex)
+        sidecar = node[].value.sidecars[index]
+
+      if not(isEmpty(sidecar)):
+        if cindex in custodyMap:
+          let dindex = indexMap[int(cindex)]
+          if dindex >= 0:
+            sidecars[dindex] = sidecar
+            inc(count)
+            if not(sidecar.isLoaded()):
+              inc(unloaded)
+
+    node.value.sidecars.reset()
+
+    if count > 0:
+      node[].value.sidecars = sidecars
+      node[].value.count = count
+      node[].value.unloaded = unloaded
+      # We do account sidecars which are useful in new configuration, but
+      # its possible that some sidecars will be left on disk which can't be
+      # used in new configuration, and we can't delete it easily. But this
+      # sidecars will be deleted as soon as sidecars with same `block_root`
+      # will be popped out from quarantine.
+      diskSidecarsCount.inc(unloaded)
+      memSidecarsCount.inc(count - unloaded)
+    else:
+      # If there no useful columns, we will mark this node for deletion.
+      nodesToRemove.add(node)
+
+  for node in nodesToRemove:
+    quarantine.removeNode(node, 0)
+
+  quarantine.diskSidecarsCount = diskSidecarsCount
+  quarantine.memSidecarsCount = memSidecarsCount
+  blob_quarantine_memory_slots_occupied.set(
+    int64(quarantine.memSidecarsCount))
+  blob_quarantine_database_slots_occupied.set(
+    int64(quarantine.diskSidecarsCount))
+
+  quarantine.maxSidecarsPerBlockCount = maxSidecarsPerBlockCount
   quarantine.indexMap = indexMap
-  quarantine.custodyColumns = @custodyColumns
-  quarantine.custodyMap = ColumnMap.init(custodyColumns)
+  quarantine.custodyColumns = toSeq(custodyMap.items)
+  quarantine.custodyMap = custodyMap

beacon_chain/consensus_object_pools/blockchain_dag.nim

@@ -2283,9 +2283,8 @@ proc loadExecutionBlockHash*(dag: ChainDAGRef, bid: BlockId): Opt[Eth2Digest] =
     return Opt.none(Eth2Digest)
 
   withBlck(blockData):
-    debugGloasComment " "
-    when consensusFork == ConsensusFork.Gloas:
-      Opt.some ZERO_HASH
+    when consensusFork >= ConsensusFork.Gloas:
+      Opt.some forkyBlck.message.body.signed_execution_payload_bid.message.block_hash
     elif consensusFork >= ConsensusFork.Bellatrix:
       Opt.some forkyBlck.message.body.execution_payload.block_hash
     else:

beacon_chain/consensus_object_pools/payload_attestation_pool.nim

@@ -16,7 +16,7 @@ import
   "."/[spec_cache, blockchain_dag],
   ../beacon_clock
 
-from ../spec/beaconstate import get_ptc_list
+from ../spec/beaconstate import get_ptc
 
 logScope: topics = "payattpool"
 
@@ -90,8 +90,7 @@ proc aggregateMessages(
         signatures: seq[CookedSig]
         ptc_index = 0
 
-      let ptc_list = get_ptc_list(forkyState.data, slot, cache)
-      for ptc_validator_index in ptc_list:
+      for ptc_validator_index in get_ptc(forkyState.data, slot, cache):
         entry.messages.withValue(ptc_validator_index, message):
           let cookedSig = message[].signature.load().valueOr:
             continue
@@ -138,13 +137,14 @@ proc getPayloadAttestationsForBlock*(
     return @[]
 
   let attestation_slot = target_slot - 1
-  var
-    payload_attestations: seq[PayloadAttestation]
-    totalCandidates = 0
 
   if attestation_slot notin pool.attestations:
     return @[]
 
+  var
+    payload_attestations: seq[PayloadAttestation]
+    totalCandidates = 0
+
   pool.attestations.withValue(attestation_slot, slotEntries):
     for beacon_block_root, entry in slotEntries[]:
       totalCandidates += 1
@@ -153,7 +153,6 @@ proc getPayloadAttestationsForBlock*(
           attestation_slot, beacon_block_root, cache)
       if aggregated.isSome():
         payload_attestations.add(aggregated.get())
-
         if payload_attestations.len >= MAX_PAYLOAD_ATTESTATIONS.int:
           break
 

beacon_chain/gossip_processing/block_processor.nim

@@ -725,18 +725,19 @@ proc addBlock*(
     return self[].storeBackfillBlock(blck, sidecarsOpt)
 
   let queueTick = Moment.now()
+
+  # If the lock is acquired already, the current block will be put on hold
+  # meaning that we'll form an unbounded queue of blocks to be processed
+  # waiting for the lock - this is similar to using an `AsyncQueue` but
+  # without the copying and transition to/from `Forked`.
+  # The lock is important to ensure that we don't process blocks out-of-order
+  # which both would upset the `storeBlock` logic and cause unnecessary
+  # quarantine traffic.
+  self.pendingStores += 1
+  await self.storeLock.acquire()
+
   let res =
     try:
-      # If the lock is acquired already, the current block will be put on hold
-      # meaning that we'll form an unbounded queue of blocks to be processed
-      # waiting for the lock - this is similar to using an `AsyncQueue` but
-      # without the copying and transition to/from `Forked`.
-      # The lock is important to ensure that we don't process blocks out-of-order
-      # which both would upset the `storeBlock` logic and cause unnecessary
-      # quarantine traffic.
-      self.pendingStores += 1
-      await self.storeLock.acquire()
-
       # Since block processing is async, we want to make sure it doesn't get
       # (re)added there while we're busy - the start of processing also removes
       # the block from the various quarantines.