NiPoPoW: align proof construction, length-prefixed parsing, and validation

AGENTS.md

@@ -30,8 +30,3 @@
 - Follow existing test patterns in similar files
 - Type annotations for public methods
 - Prefer immutable data structures and functional patterns
-
-## Development Restrictions
-- **Code Changes**: Only modify code in `src/test/` folders
-- **Production Code**: Do not touch production code in `src/main/` directories
-- **Test Focus**: All development work should be test-related only

ergo-core/src/main/scala/org/ergoplatform/modifiers/history/extension/ExtensionCandidate.scala

@@ -6,7 +6,6 @@ import scorex.crypto.authds.LeafData
 import scorex.crypto.authds.merkle.{BatchMerkleProof, Leaf, MerkleProof, MerkleTree}
 import scorex.crypto.hash.Digest32
 import scorex.util.ModifierId
-import scala.annotation.nowarn
 import scala.collection.mutable
 /**
   * Extension block section with header id not provided
@@ -38,20 +37,18 @@ class ExtensionCandidate(val fields: Seq[(Array[Byte], Array[Byte])]) {
       .flatMap(kv => merkleTree.proofByElement(Leaf[Digest32](LeafData @@ kv)(Algos.hash)))
 
   /**
-    * Constructs BatchMerkleProof for a list of interlinks
-    * Note - only accounts for interlink vector fields in the extension
+    * Constructs a BatchMerkleProof for the requested extension fields
     *
     * @param keys - array of 2-byte keys
     * @return BatchMerkleProof or None if keys not found
     */
-  @nowarn
   def batchProofFor(keys: Array[Byte]*): Option[BatchMerkleProof[Digest32]] = {
     val indices = keys.flatMap(key => fields.find(_._1 sameElements key)
       .map(Extension.kvToLeaf)
       .map(kv => Leaf[Digest32](LeafData @@ kv)(Algos.hash).hash)
-      .flatMap(leafData => interlinksMerkleTree.elementsHashIndex.get(
+      .flatMap(leafData => merkleTree.elementsHashIndex.get(
         new mutable.WrappedArray.ofByte(leafData))))
-    if (indices.isEmpty) None else interlinksMerkleTree.proofByIndices(indices)(Algos.hash)
+    if (indices.isEmpty) None else merkleTree.proofByIndices(indices)(Algos.hash)
   }
 }
 

ergo-core/src/main/scala/org/ergoplatform/modifiers/history/popow/NipopowAlgos.scala

@@ -67,14 +67,18 @@ class NipopowAlgos(val chainSettings: ChainSettings) {
     */
   def maxLevelOf(header: Header): Int =
     if (!header.isGenesis) {
-      val requiredTarget = org.ergoplatform.mining.q / DifficultySerializer.decodeCompactBits(header.nBits)
+      val decodedDifficulty = DifficultySerializer.decodeCompactBits(header.nBits)
+      require(decodedDifficulty > 0, "Decoded difficulty target must be positive")
+      val requiredTarget = org.ergoplatform.mining.q / decodedDifficulty
       val realTarget = powScheme.powHit(header).doubleValue
       val level = log2(requiredTarget.doubleValue) - log2(realTarget.doubleValue)
       level.toInt
     } else {
       Int.MaxValue
     }
 
+  def hasValidPow(header: Header): Boolean = powScheme.validate(header).isSuccess
+
   /**
     * Computes best score of a given chain.
     * The score value depends on number of µ-superblocks in the given chain.
@@ -96,6 +100,8 @@ class NipopowAlgos(val chainSettings: ChainSettings) {
     * end function
     */
   def bestArg(chain: Seq[Header])(m: Int): Int = {
+    PoPowParams.requireValidM(m)
+
     @scala.annotation.tailrec
     def loop(level: Int, acc: Seq[(Int, Int)] = Seq.empty): Seq[(Int, Int)] =
       if (level == 0) {
@@ -130,7 +136,7 @@ class NipopowAlgos(val chainSettings: ChainSettings) {
     val k = params.k
     val m = params.m
 
-    require(params.k >= 1, s"$k < 1")
+    PoPowParams.requireValid(m, k)
     require(chain.lengthCompare(k + m) >= 0, s"Can not prove chain of size < ${k + m}")
     require(chain.head.header.isGenesis, "Can not prove non-anchored chain")
 

ergo-core/src/main/scala/org/ergoplatform/modifiers/history/popow/NipopowProof.scala

@@ -51,7 +51,9 @@ case class NipopowProof(popowAlgos: NipopowAlgos,
     */
   def isBetterThan(that: NipopowProof): Boolean = {
     try {
-      if (this.isValid && that.isValid) {
+      if (this.m != that.m || this.k != that.k) {
+        false
+      } else if (this.isValid && that.isValid) {
         popowAlgos.lowestCommonAncestor(headersChain, that.headersChain)
           .map(h => headersChain.filter(_.height > h.height) -> that.headersChain.filter(_.height > h.height))
           .exists({ case (thisDivergingChain, thatDivergingChain) =>
@@ -72,7 +74,20 @@ case class NipopowProof(popowAlgos: NipopowAlgos,
     * @return true if the proof is valid
     */
   lazy val isValid: Boolean = {
-    this.hasValidConnections && this.hasValidHeights && this.hasValidProofs && this.hasValidDifficultyHeaders
+    this.hasValidParams &&
+      this.hasValidConnections &&
+      this.hasValidHeights &&
+      this.hasValidProofs &&
+      this.hasValidDifficultyHeaders &&
+      this.hasValidPow
+  }
+
+  /**
+    * Checks proof parameters and the exact suffix cardinality before any
+    * parameter-dependent scoring or validation work.
+    */
+  lazy val hasValidParams: Boolean = {
+    PoPowParams.areValid(m, k) && suffixTail.lengthCompare(k - 1) == 0
   }
 
   /**
@@ -155,6 +170,8 @@ case class NipopowProof(popowAlgos: NipopowAlgos,
       suffixHead.checkInterlinksProof()
   }
 
+  lazy val hasValidPow: Boolean = headersChain.forall(popowAlgos.hasValidPow)
+
 }
 
 object NipopowProof {
@@ -185,9 +202,27 @@ object NipopowProof {
 
 }
 
+object NipopowProofSerializer {
+  private val MaxProofElements = PoPowParams.MaxProofElements
+
+  private def requireWithinLimit(value: Int, limit: Int, what: String): Unit =
+    require(value <= limit, s"$what $value exceeds sanity limit $limit")
+
+  private def readLengthPrefixed[T](r: Reader,
+                                    limit: Int,
+                                    what: String)
+                                   (parse: Array[Byte] => T): T = {
+    val declaredLength = r.getUInt().toIntExact
+    requireWithinLimit(declaredLength, limit, s"$what length")
+    parse(r.getBytes(declaredLength))
+  }
+}
+
 class NipopowProofSerializer(poPowAlgos: NipopowAlgos) extends ErgoSerializer[NipopowProof] {
+  import NipopowProofSerializer._
 
   override def serialize(obj: NipopowProof, w: Writer): Unit = {
+    require(obj.hasValidParams, "Invalid NiPoPoW proof parameters or suffix length")
     w.putUInt(obj.m.toLong)
     w.putUInt(obj.k.toLong)
     w.putUInt(obj.prefix.size.toLong)
@@ -211,19 +246,27 @@ class NipopowProofSerializer(poPowAlgos: NipopowAlgos) extends ErgoSerializer[Ni
   override def parse(r: Reader): NipopowProof = {
     val m = r.getUInt().toIntExact
     val k = r.getUInt().toIntExact
+    PoPowParams.requireValid(m, k)
     val prefixSize = r.getUInt().toIntExact
+    requireWithinLimit(prefixSize, MaxProofElements, "prefix count")
     val prefix = (0 until prefixSize).map { _ =>
-      val size = r.getUInt().toIntExact
-      PoPowHeaderSerializer.parseBytes(r.getBytes(size))
+      readLengthPrefixed(r, PoPowHeaderSerializer.MaxSerializedBytes, "prefix element")(
+        PoPowHeaderSerializer.parseBytes)
     }
-    val suffixHeadSize = r.getUInt().toIntExact
-    val suffixHead = PoPowHeaderSerializer.parseBytes(r.getBytes(suffixHeadSize))
+    val suffixHead = readLengthPrefixed(r, PoPowHeaderSerializer.MaxSerializedBytes, "suffix head")(
+      PoPowHeaderSerializer.parseBytes)
     val suffixSize = r.getUInt().toIntExact
+    requireWithinLimit(suffixSize, MaxProofElements, "suffix count")
+    require(suffixSize == k - 1,
+      s"NiPoPoW suffix length ${suffixSize + 1} does not match k parameter $k")
     val suffixTail = (0 until suffixSize).map { _ =>
-      val size = r.getUInt().toIntExact
-      HeaderSerializer.parseBytes(r.getBytes(size))
+      readLengthPrefixed(r, PoPowHeaderSerializer.MaxHeaderBytes, "suffix tail")(
+        HeaderSerializer.parseBytes)
     }
-    val continuous = if (r.getByte() == 1) true else false
+    val continuousByte = r.getByte()
+    require(continuousByte == 0 || continuousByte == 1,
+      s"invalid NiPoPoW continuous mode byte ${continuousByte & 0xff}")
+    val continuous = continuousByte == 1
     NipopowProof(poPowAlgos, m, k, prefix, suffixHead, suffixTail, continuous)
   }